@igniter-js/cli 0.1.0

package/dist/utils/consts.d.ts

@@ -0,0 +1,26 @@
+export declare const PROJECT_STRUCTURE: {
+    docs: string[];
+    public: never[];
+    scripts: string[];
+    '.github/actions': string[];
+    'src/configs': string[];
+    'src/core/design-system': never[];
+    'src/core/utils': never[];
+    'src/core/providers': never[];
+    'src/features': string[];
+};
+export declare const LIA_FILES: {
+    'project_requirement.md': string;
+    'detailed_app_flow.md': string;
+    'tech_stack_and_packages.md': string;
+    'file_structure.md': string;
+    'schema_design.md': string;
+};
+export declare const DEPENDENCIES: {
+    required: string[];
+};
+export declare const CONFIG_FILES: {
+    name: string;
+    template: string;
+}[];
+export declare const INTERACTIVE_COMMANDS: string[];

package/dist/utils/consts.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERACTIVE_COMMANDS = exports.CONFIG_FILES = exports.DEPENDENCIES = exports.LIA_FILES = exports.PROJECT_STRUCTURE = void 0;
+exports.PROJECT_STRUCTURE = {
+    docs: ['.gitkeep'],
+    public: [],
+    scripts: ['.gitkeep'],
+    '.github/actions': ['.gitkeep'],
+    'src/configs': ['.gitkeep'],
+    'src/core/design-system': [],
+    'src/core/utils': [],
+    'src/core/providers': [],
+    'src/features': ['.gitkeep'],
+};
+exports.LIA_FILES = {
+    'project_requirement.md': '',
+    'detailed_app_flow.md': '',
+    'tech_stack_and_packages.md': '',
+    'file_structure.md': '',
+    'schema_design.md': ''
+};
+exports.DEPENDENCIES = {
+    required: ['docker', 'node', 'npm'],
+};
+exports.CONFIG_FILES = [
+    { name: 'README.md', template: 'readme' },
+    { name: 'eslintrc.json', template: 'eslintrc' },
+    { name: 'components.json', template: 'components.json' },
+    { name: 'docker-compose.yml', template: 'docker-compose' },
+    { name: 'vitest.config.ts', template: 'vitest.config' },
+];
+exports.INTERACTIVE_COMMANDS = [
+    'shadcn',
+];

package/dist/utils/handlebars-helpers.d.ts

@@ -0,0 +1 @@
+export declare function registerHelpers(): void;

package/dist/utils/handlebars-helpers.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerHelpers = registerHelpers;
+const handlebars_1 = __importDefault(require("handlebars"));
+function registerHelpers() {
+    handlebars_1.default.registerHelper('camelCase', (str) => {
+        return str.replace(/[-_]([a-z])/g, (g) => g[1].toUpperCase());
+    });
+    handlebars_1.default.registerHelper('pascalCase', (str) => {
+        const camelCase = str.replace(/[-_]([a-z])/g, (g) => g[1].toUpperCase());
+        return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+    });
+    handlebars_1.default.registerHelper('kebabCase', (str) => {
+        return str
+            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/[\s_]+/g, '-')
+            .toLowerCase();
+    });
+    handlebars_1.default.registerHelper('snakeCase', (str) => {
+        return str
+            .replace(/([a-z])([A-Z])/g, '$1_$2')
+            .replace(/[\s-]+/g, '_')
+            .toLowerCase();
+    });
+    handlebars_1.default.registerHelper('lowerFirstLetter', (str) => {
+        return str.charAt(0).toLowerCase() + str.slice(1);
+    });
+    handlebars_1.default.registerHelper('lowerCase', (str) => {
+        return str.toLowerCase();
+    });
+    /**
+     * Handlebars helper to compare if two values are equal
+     * @param {string} firstValue - First value to compare
+     * @param {string} secondValue - Second value to compare
+     * @returns {boolean} Returns true if values are equal, false otherwise
+     */
+    handlebars_1.default.registerHelper('equals', (firstValue, secondValue) => {
+        return firstValue === secondValue;
+    });
+}

package/dist/utils/helpers.d.ts

@@ -0,0 +1,12 @@
+export declare abstract class CLIHelper {
+    protected execCommand(command: string): void;
+    protected createDir(dir: string): void;
+    protected createFile(filePath: string, content?: string): void;
+    protected updateFile(filePath: string, content: string): void;
+    protected checkDependencies(dependencies: string[]): void;
+    protected delay(ms: number): Promise<void>;
+    protected loadJSON(filePath: string): any;
+    protected saveJSON(filePath: string, data: any): void;
+    protected createDirectoryStructure(structure: Record<string, any>, basePath?: string): void;
+    protected installDependencies(dependencies: Record<string, string>, dev?: boolean): void;
+}

package/dist/utils/helpers.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIHelper = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const consts_1 = require("./consts");
+class CLIHelper {
+    execCommand(command) {
+        try {
+            const needsInteraction = consts_1.INTERACTIVE_COMMANDS.some((cmd) => command.includes(cmd));
+            if (needsInteraction) {
+                console.log(`\n📦 Executing: ${command}\n`);
+                (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+                console.log('\n✅ Command completed successfully\n');
+            }
+            else {
+                (0, child_process_1.execSync)(command, {
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    encoding: 'utf-8'
+                });
+            }
+        }
+        catch (error) {
+            console.error(`Failed to execute command: ${command} \n${error}`);
+            process.exit(1);
+        }
+    }
+    createDir(dir) {
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+    }
+    createFile(filePath, content = '') {
+        const dir = path_1.default.dirname(filePath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        fs_1.default.writeFileSync(filePath, content);
+    }
+    updateFile(filePath, content) {
+        fs_1.default.writeFileSync(filePath, content);
+    }
+    checkDependencies(dependencies) {
+        for (const dep of dependencies) {
+            try {
+                (0, child_process_1.execSync)(`${dep} --version`, { stdio: 'pipe' });
+            }
+            catch (error) {
+                console.error(`Required dependency not found: ${dep}. Please install it before proceeding. \n${error}`);
+                process.exit(1);
+            }
+        }
+    }
+    async delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    loadJSON(filePath) {
+        try {
+            return JSON.parse(fs_1.default.readFileSync(filePath, 'utf8'));
+        }
+        catch (error) {
+            console.error(`Failed to load JSON file: ${filePath} \n${error}`);
+            process.exit(1);
+        }
+    }
+    saveJSON(filePath, data) {
+        try {
+            fs_1.default.writeFileSync(filePath, JSON.stringify(data, null, 2));
+        }
+        catch (error) {
+            console.error(`Failed to save JSON file: ${filePath} \n${error}`);
+            process.exit(1);
+        }
+    }
+    createDirectoryStructure(structure, basePath = '') {
+        Object.entries(structure).forEach(([dir, content]) => {
+            const fullPath = path_1.default.join(basePath, dir);
+            this.createDir(fullPath);
+            if (Array.isArray(content)) {
+                content.forEach(file => {
+                    if (typeof file === 'string') {
+                        this.createFile(path_1.default.join(fullPath, file));
+                    }
+                });
+            }
+            else if (content && typeof content === 'object') {
+                this.createDirectoryStructure(content, fullPath);
+            }
+        });
+    }
+    installDependencies(dependencies, dev = false) {
+        const deps = Object.entries(dependencies)
+            .map(([name, version]) => `${name}@${version}`)
+            .join(' ');
+        this.execCommand(`npm install ${dev ? '-D ' : ''}${deps}`);
+    }
+}
+exports.CLIHelper = CLIHelper;

package/dist/utils/prisma-schema-parser.d.ts

@@ -0,0 +1,59 @@
+interface ParsedField {
+    name: string;
+    type: string;
+    zodType: string;
+    description: string;
+    isOptional: boolean;
+    isList: boolean;
+    hasDefault: boolean;
+    isEnum?: boolean;
+    enumValues?: string[];
+    relations?: {
+        type: 'one-to-one' | 'one-to-many' | 'many-to-many';
+        model: string;
+        fields: string[];
+        references: string[];
+    };
+}
+export declare class PrismaSchemaParser {
+    private readonly schemaPath;
+    private schemaContent;
+    constructor(basePath?: string);
+    /**
+     * Loads the Prisma schema file content
+     */
+    private loadSchema;
+    /**
+     * Gets the raw schema content
+     */
+    getSchemaContent(): string;
+    /**
+     * Checks if a model exists in the Prisma schema
+     */
+    hasModel(modelName: string): boolean;
+    /**
+     * Gets fields from a specific model
+     */
+    getModelFields(modelName: string): ParsedField[];
+    /**
+     * Parses field strings into structured field objects
+     */
+    private parseFields;
+    /**
+     * Parses a single field line into a structured field object
+     */
+    private parseFieldLine;
+    /**
+     * Parses a relation decorator into a structured object
+     */
+    private parseRelation;
+    /**
+     * Decodes HTML entities in a string
+     */
+    private decodeHtmlEntities;
+    /**
+     * Converts Prisma types to Zod types
+     */
+    private getZodType;
+}
+export {};

package/dist/utils/prisma-schema-parser.js

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaSchemaParser = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class PrismaSchemaParser {
+    constructor(basePath = process.cwd()) {
+        this.schemaContent = '';
+        this.schemaPath = path_1.default.join(basePath, 'prisma/schema.prisma');
+    }
+    /**
+     * Loads the Prisma schema file content
+     */
+    loadSchema() {
+        if (!fs_1.default.existsSync(this.schemaPath)) {
+            throw new Error('Prisma schema file not found');
+        }
+        this.schemaContent = fs_1.default.readFileSync(this.schemaPath, 'utf-8');
+    }
+    /**
+     * Gets the raw schema content
+     */
+    getSchemaContent() {
+        this.loadSchema();
+        return this.schemaContent;
+    }
+    /**
+     * Checks if a model exists in the Prisma schema
+     */
+    hasModel(modelName) {
+        this.loadSchema();
+        const modelRegex = new RegExp(`model\\s+${modelName}\\s*{`, 'i');
+        return modelRegex.test(this.schemaContent);
+    }
+    /**
+     * Gets fields from a specific model
+     */
+    getModelFields(modelName) {
+        this.loadSchema();
+        if (!this.hasModel(modelName)) {
+            return [];
+        }
+        const modelRegex = new RegExp(`model\\s+${modelName}\\s*{([^}]*)}`, 'i');
+        const modelMatch = this.schemaContent.match(modelRegex);
+        if (!modelMatch || !modelMatch[1]) {
+            return [];
+        }
+        const fieldsContent = modelMatch[1].trim();
+        return this.parseFields(fieldsContent);
+    }
+    /**
+     * Parses field strings into structured field objects
+     */
+    parseFields(fieldsContent) {
+        this.loadSchema();
+        const fieldLines = fieldsContent.split('\n');
+        const fields = [];
+        for (const line of fieldLines) {
+            const trimmedLine = line.trim();
+            if (!trimmedLine || trimmedLine.startsWith('@@'))
+                continue;
+            const field = this.parseFieldLine(trimmedLine);
+            if (field) {
+                fields.push(field);
+            }
+        }
+        return fields;
+    }
+    /**
+     * Parses a single field line into a structured field object
+     */
+    parseFieldLine(line) {
+        this.loadSchema();
+        // Basic field pattern: name type modifiers
+        const fieldPattern = /^(\w+)\s+(\w+)(\?|\[\])?\s*(@\w+(?:\([^)]*\))?)*$/;
+        const match = line.match(fieldPattern);
+        if (!match)
+            return null;
+        const [, name, type] = match;
+        const modifiers = line.slice(match[0].length).trim();
+        const isOptional = line.includes('?');
+        const isList = line.includes('[]');
+        const hasDefault = modifiers.includes('@default');
+        // Skip internal Prisma fields
+        if (['id', 'createdAt', 'updatedAt'].includes(name)) {
+            return null;
+        }
+        // Verifica se é um enum
+        const isEnum = this.schemaContent.includes(`enum ${type} {`);
+        // Parse relations
+        let relations = undefined;
+        if (line.includes('@relation')) {
+            const relationMatch = line.match(/@relation\([^)]*\)/);
+            if (relationMatch) {
+                relations = this.parseRelation(relationMatch[0], isList);
+            }
+        }
+        return {
+            name,
+            type,
+            zodType: this.getZodType(type, isOptional, isList),
+            description: `${name} field`,
+            isOptional,
+            isList,
+            hasDefault,
+            isEnum,
+            relations
+        };
+    }
+    /**
+     * Parses a relation decorator into a structured object
+     */
+    parseRelation(relationString, isList) {
+        var _a;
+        const relationDetails = (_a = relationString.match(/@relation\(([^)]+)\)/)) === null || _a === void 0 ? void 0 : _a[1].split(',');
+        if (!relationDetails)
+            return undefined;
+        const nameMatch = relationDetails.find(detail => detail.trim().startsWith('name:'));
+        const fieldsMatch = relationDetails.find(detail => detail.trim().startsWith('fields:'));
+        const referencesMatch = relationDetails.find(detail => detail.trim().startsWith('references:'));
+        if (nameMatch && fieldsMatch && referencesMatch) {
+            const model = nameMatch.split(':')[1].trim().replace(/['"]/g, '');
+            const fields = fieldsMatch.split(':')[1].trim().replace(/\[|\]/g, '').split(',').map(f => f.trim());
+            const references = referencesMatch.split(':')[1].trim().replace(/\[|\]/g, '').split(',').map(f => f.trim());
+            return {
+                type: fields.length > 1 || references.length > 1 ? 'many-to-many' : (isList ? 'one-to-many' : 'one-to-one'),
+                model,
+                fields,
+                references
+            };
+        }
+        return undefined;
+    }
+    /**
+     * Decodes HTML entities in a string
+     */
+    decodeHtmlEntities(text) {
+        return text
+            .replace(/&/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#x27;/g, "'")
+            .replace(/&#x60;/g, '`');
+    }
+    /**
+     * Converts Prisma types to Zod types
+     */
+    getZodType(type, isOptional = false, isList = false) {
+        this.loadSchema();
+        // Verifica se é um enum primeiro
+        const enumMatch = this.schemaContent.match(new RegExp(`enum\\s+${type}\\s*{([^}]*)}`, 'i'));
+        if (enumMatch) {
+            const enumValues = enumMatch[1]
+                .trim()
+                .split('\n')
+                .map(v => v.trim())
+                .filter(Boolean)
+                .map(v => this.decodeHtmlEntities(v)) // Decodifica HTML entities
+                .map(v => v.replace(/['"]/g, '').trim());
+            return `z.enum([${enumValues.map(v => `'${v}'`).join(', ')}])`;
+        }
+        const uuidMatch = this.schemaContent.match(/@default\(uuid\((\d+)?\)\)/);
+        const uuidVersion = uuidMatch ? (uuidMatch[1] || '4') : null;
+        const typeMap = {
+            'String': 'z.string()',
+            'Int': 'z.number().int()',
+            'Float': 'z.number()',
+            'Boolean': 'z.boolean()',
+            'DateTime': 'z.date()',
+            'Json': 'z.any()',
+            'BigInt': 'z.bigint()',
+            'Decimal': 'z.number()',
+            'Bytes': 'z.instanceof(Buffer)',
+            'UUID': `z.string().uuid(${uuidVersion ? `{ version: ${uuidVersion} }` : ''})`,
+        };
+        // Handle relationships
+        if (!typeMap[type]) {
+            if (isList) {
+                return 'z.array(z.string().min(1))';
+            }
+            return 'z.string().min(1)';
+        }
+        let zodType = typeMap[type] || 'z.any()';
+        if (isList) {
+            zodType = `z.array(${zodType})`;
+        }
+        if (isOptional) {
+            zodType = `${zodType}.optional().nullable()`;
+        }
+        return zodType;
+    }
+}
+exports.PrismaSchemaParser = PrismaSchemaParser;

package/dist/utils/template-handler.d.ts

@@ -0,0 +1,6 @@
+import Handlebars from 'handlebars';
+export declare class TemplateHandler {
+    private static templatesPath;
+    static render(templateName: string, data: any, customPath?: string): string;
+    static registerHelper(name: string, fn: Handlebars.HelperDelegate): void;
+}

package/dist/utils/template-handler.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateHandler = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+class TemplateHandler {
+    static render(templateName, data, customPath) {
+        if (!templateName.endsWith('.hbs')) {
+            templateName = `${templateName}.hbs`;
+        }
+        if (customPath) {
+            this.templatesPath = path_1.default.join(__dirname, '..', customPath);
+        }
+        const templatePath = path_1.default.join(this.templatesPath, templateName);
+        const templateContent = (0, fs_1.readFileSync)(templatePath, 'utf-8');
+        const template = handlebars_1.default.compile(templateContent);
+        const result = template(data);
+        // If template is for .env file, add an extra line before appending
+        if (templateName === '.env' || templateName.endsWith('env')) {
+            return '\n' + result;
+        }
+        return result;
+    }
+    static registerHelper(name, fn) {
+        handlebars_1.default.registerHelper(name, fn);
+    }
+}
+exports.TemplateHandler = TemplateHandler;
+TemplateHandler.templatesPath = path_1.default.join(__dirname, '..', 'templates');

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@igniter-js/cli",
+  "version": "0.1.0",
+  "description": "Igniter CLI for projects using Igniter Framework",
+  "main": "dist/index.js",
+  "homepage": "https://felipebarcelospro.github.io/igniter",
+  "bin": {
+    "igniter": "dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/felipebarcelospro/igniter-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/felipebarcelospro/igniter-cli/issues"
+  },
+  "scripts": {
+    "build": "tsc && mkdir -p dist/templates && cp -r src/templates/* dist/templates",
+    "dev": "ts-node src/index.ts",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.{ts,hbs}\"",
+    "prepublishOnly": "bun run build",
+    "test": "echo \"No tests specified\" && exit 0",
+    "release": "npm publish --access public"
+  },
+  "keywords": [
+    "igniter",
+    "igniter-js",
+    "next.js",
+    "cli",
+    "generator",
+    "feature-first",
+    "typescript",
+    "scaffolding",
+    "boilerplate",
+    "code-generation"
+  ],
+  "author": "Felipe Barcelos <felipe.barcelos@nubler.io>",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "handlebars": "^4.7.8",
+    "inquirer": "^8.2.6",
+    "ora": "^5.4.1",
+    "reflect-metadata": "^0.2.2",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^8.2.10",
+    "@types/node": "^20.10.2",
+    "@typescript-eslint/eslint-plugin": "^6.13.1",
+    "@typescript-eslint/parser": "^6.13.1",
+    "eslint": "^8.55.0",
+    "prettier": "^3.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.2"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}