@diagramers/cli/dist/services/table-generator.js

Diagramers CLI - Command-line tools for managing Diagramers projects

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateTable = generateTable;
const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
async function generateTable(tableName) {
    // Validate table name
    if (!tableName || !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(tableName)) {
        throw new Error('Invalid table name. Use only letters, numbers, hyphens, and underscores. Must start with a letter.');
    }
    const tableNameCapitalized = tableName.charAt(0).toUpperCase() + tableName.slice(1);
    const currentDir = process.cwd();
    // Check for required API project structure
    const requiredDirs = [
        'src/entities',
        'src/schemas'
    ];
    const missingDirs = requiredDirs.filter(dir => !fs.existsSync(path.join(currentDir, dir)));
    if (missingDirs.length > 0) {
        throw new Error(`This command should be run from a diagramers API project. Missing directories: ${missingDirs.join(', ')}`);
    }
    console.log('📝 Creating entity...');
    const entityContent = generateEntityContent(tableName, tableNameCapitalized);
    fs.writeFileSync(path.join(currentDir, 'src/entities', `${tableName}.ts`), entityContent);
    console.log('📋 Creating schema...');
    const schemaContent = generateSchemaContent(tableName, tableNameCapitalized);
    fs.writeFileSync(path.join(currentDir, 'src/schemas', `${tableName}.ts`), schemaContent);
    // Update dbcontext to include the new entity
    updateDbContext(currentDir, tableName, tableNameCapitalized);
    console.log('✅ Table generation completed!');
    console.log(`📊 Entity: src/entities/${tableName}.ts`);
    console.log(`📋 Schema: src/schemas/${tableName}.ts`);
    console.log('🔄 dbcontext.ts updated');
}
function generateEntityContent(tableName, tableNameCapitalized) {
    return `import * as mongoose from 'mongoose';
import { ObjectId } from "bson";

export interface I${tableNameCapitalized} extends mongoose.Document {
    _id: ObjectId,
    name: string,
    description?: string,
    status: number,
    createdAt: Date,
    updatedAt: Date
}`;
}
function generateSchemaContent(tableName, tableNameCapitalized) {
    return `import * as mongoose from 'mongoose';
import { I${tableNameCapitalized} } from '../entities/${tableName}';

export const ${tableName}Schema = new mongoose.Schema(
    {
        name: {
            type: mongoose.SchemaTypes.String,
            required: true,
        },
        description: {
            type: mongoose.SchemaTypes.String,
            required: false,
        },
        status: {
            type: mongoose.SchemaTypes.Number,
            default: 1,
        }
    },
    { timestamps: true, suppressReservedKeysWarning: true },
);

export const ${tableNameCapitalized}Entity = mongoose.model<I${tableNameCapitalized}>('${tableName}', ${tableName}Schema);`;
}
function updateDbContext(currentDir, tableName, tableNameCapitalized) {
    const dbcontextPath = path.join(currentDir, 'src/helpers/dbcontext.ts');
    if (!fs.existsSync(dbcontextPath)) {
        console.log('⚠️ dbcontext.ts not found, skipping dbcontext update');
        return;
    }
    let dbcontextContent = fs.readFileSync(dbcontextPath, 'utf8');
    // Add import
    const importStatement = `import { ${tableNameCapitalized}Entity } from '../schemas/${tableName}';`;
    if (!dbcontextContent.includes(importStatement)) {
        // Find the last import statement and add after it
        const importRegex = /import.*from.*['"];?\s*$/gm;
        const matches = [...dbcontextContent.matchAll(importRegex)];
        if (matches.length > 0) {
            const lastImport = matches[matches.length - 1];
            const insertIndex = lastImport.index + lastImport[0].length;
            dbcontextContent = dbcontextContent.slice(0, insertIndex) + '\n' + importStatement + dbcontextContent.slice(insertIndex);
        }
    }
    // Add to dbcontext object
    const dbcontextObjectRegex = /export\s+default\s*\{([^}]*)\}/s;
    const match = dbcontextContent.match(dbcontextObjectRegex);
    if (match) {
        const objectContent = match[1];
        if (!objectContent.includes(`${tableNameCapitalized}Entity`)) {
            const newObjectContent = objectContent.trim() + `,\n    ${tableNameCapitalized}Entity`;
            dbcontextContent = dbcontextContent.replace(dbcontextObjectRegex, `export default {$1${newObjectContent}\n}`);
        }
    }
    fs.writeFileSync(dbcontextPath, dbcontextContent);
    console.log('📊 Updated dbcontext.ts');
}
//# sourceMappingURL=table-generator.js.map