generate-ui-cli 2.1.7 → 2.3.0

package/dist/commands/generate.js

@@ -10,26 +10,40 @@ const load_openapi_1 = require("../openapi/load-openapi");
 const screen_generator_1 = require("../generators/screen.generator");
 const screen_merge_1 = require("../generators/screen.merge");
 const permissions_1 = require("../license/permissions");
-const device_1 = require("../license/device");
 const telemetry_1 = require("../telemetry");
 const user_config_1 = require("../runtime/user-config");
+const logger_1 = require("../runtime/logger");
+const project_config_1 = require("../runtime/project-config");
 async function generate(options) {
     void (0, telemetry_1.trackCommand)('generate', options.telemetryEnabled);
+    const projectConfig = (0, project_config_1.findProjectConfig)(process.cwd());
+    const configuredOpenApi = (0, project_config_1.pickConfiguredPath)(projectConfig.config, 'openapi');
+    const configuredOutput = (0, project_config_1.pickConfiguredPath)(projectConfig.config, 'output') ??
+        (0, project_config_1.pickConfiguredPath)(projectConfig.config, 'schemas');
+    const openApiPath = (0, project_config_1.resolveOptionalPath)(options.openapi, configuredOpenApi, projectConfig.configPath);
+    if (!openApiPath) {
+        throw new Error('Missing OpenAPI file.\n' +
+            'Use --openapi <path> or set "openapi" (or "paths.openapi") in generateui-config.json.');
+    }
     /**
      * Caminho absoluto do OpenAPI (YAML)
      * Ex: /Users/.../generateui-playground/realWorldOpenApi.yaml
      */
-    const openApiPath = path_1.default.resolve(process.cwd(), options.openapi);
+    (0, logger_1.logStep)(`OpenAPI: ${openApiPath}`);
     /**
      * Raiz do playground (onde está o YAML)
      */
     const projectRoot = path_1.default.dirname(openApiPath);
+    (0, logger_1.logDebug)(`Project root: ${projectRoot}`);
     /**
      * Onde o Angular consome os arquivos
      */
-    const generateUiRoot = resolveGenerateUiRoot(projectRoot, options.output);
+    const generateUiRoot = resolveGenerateUiRoot(projectRoot, (0, project_config_1.resolveOptionalPath)(options.output, configuredOutput, projectConfig.configPath) ?? undefined);
+    (0, logger_1.logStep)(`Schemas output: ${generateUiRoot}`);
     const generatedDir = path_1.default.join(generateUiRoot, 'generated');
     const overlaysDir = path_1.default.join(generateUiRoot, 'overlays');
+    (0, logger_1.logDebug)(`Generated dir: ${generatedDir}`);
+    (0, logger_1.logDebug)(`Overlays dir: ${overlaysDir}`);
     (0, user_config_1.updateUserConfig)(config => ({
         ...config,
         lastSchemasPath: generateUiRoot
@@ -41,23 +55,26 @@ async function generate(options) {
      */
     const routes = [];
     const usedOperationIds = new Set();
+    const resourceMap = new Map();
+    const screenByOpId = new Map();
+    const viewDefaults = [];
     const permissions = await (0, permissions_1.getPermissions)();
-    const device = (0, device_1.loadDeviceIdentity)();
-    if (permissions.features.maxGenerations > -1 &&
-        device.freeGenerationsUsed >= permissions.features.maxGenerations) {
-        throw new Error('🔒 Você já utilizou sua geração gratuita.\n' +
-            'O plano Dev libera gerações ilimitadas, regeneração segura e UI inteligente.\n' +
-            '👉 Execute `generate-ui login` para continuar.');
+    const subscriptionReason = normalizeSubscriptionReason(permissions.subscription.reason);
+    (0, logger_1.logDebug)(`License: status=${permissions.subscription.status}, overrides=${permissions.features.uiOverrides}, safeRegen=${permissions.features.safeRegeneration}, intelligent=${permissions.features.intelligentGeneration}`);
+    if (subscriptionReason) {
+        console.log(`ℹ Subscription: ${subscriptionReason}`);
     }
     /**
      * Parse do OpenAPI (já com $refs resolvidos)
      */
     const api = await (0, load_openapi_1.loadOpenApi)(openApiPath);
     const paths = api.paths ?? {};
+    (0, logger_1.logDebug)(`OpenAPI paths: ${Object.keys(paths).length}`);
     /**
      * Itera por todos os endpoints
      */
     const operationIds = new Set();
+    const operationFileNames = new Set();
     for (const [pathKey, pathItem] of Object.entries(paths)) {
         for (const [method, rawOp] of Object.entries(pathItem)) {
             const op = rawOp;
@@ -66,6 +83,8 @@ async function generate(options) {
             const operationId = op.operationId ||
                 buildOperationId(method.toLowerCase(), pathKey, usedOperationIds);
             operationIds.add(operationId);
+            operationFileNames.add(toSafeFileName(operationId));
+            recordResourceOp(resourceMap, pathKey, method.toLowerCase(), operationId, op);
             const endpoint = {
                 operationId,
                 path: pathKey,
@@ -77,7 +96,8 @@ async function generate(options) {
              * Gera o ScreenSchema completo
              */
             const screenSchema = (0, screen_generator_1.generateScreen)(endpoint, api);
-            const fileName = `${operationId}.screen.json`;
+            screenByOpId.set(operationId, screenSchema);
+            const fileName = `${toSafeFileName(operationId)}.screen.json`;
             /**
              * 1️⃣ generated → SEMPRE sobrescrito (base técnica)
              */
@@ -117,16 +137,124 @@ async function generate(options) {
              */
             routes.push({
                 path: operationId,
-                operationId
+                operationId,
+                label: toLabel(screenSchema.entity
+                    ? String(screenSchema.entity)
+                    : operationId),
+                group: inferRouteGroup(op, pathKey)
+            });
+            viewDefaults.push({
+                key: operationId,
+                view: 'list'
             });
             console.log(`✔ Generated ${operationId}`);
         }
     }
+    const canOverride = permissions.features.uiOverrides;
+    const canRegenerateSafely = permissions.features.safeRegeneration;
+    const intelligentEnabled = Boolean(permissions.features.intelligentGeneration);
+    if (intelligentEnabled) {
+        const adminSchemas = buildAdminSchemas(resourceMap, usedOperationIds, screenByOpId);
+        for (const admin of adminSchemas) {
+            const fileName = `${toSafeFileName(admin.api.operationId)}.screen.json`;
+            const generatedPath = path_1.default.join(generatedDir, fileName);
+            fs_1.default.writeFileSync(generatedPath, JSON.stringify(admin, null, 2));
+            const overlayPath = path_1.default.join(overlaysDir, fileName);
+            if (canOverride && canRegenerateSafely) {
+                const overlay = fs_1.default.existsSync(overlayPath)
+                    ? JSON.parse(fs_1.default.readFileSync(overlayPath, 'utf-8'))
+                    : null;
+                const merged = (0, screen_merge_1.mergeScreen)(admin, overlay, null, {
+                    openapiVersion: api?.info?.version || 'unknown',
+                    debug: options.debug
+                });
+                fs_1.default.writeFileSync(overlayPath, JSON.stringify(merged.screen, null, 2));
+            }
+            else if (!fs_1.default.existsSync(overlayPath)) {
+                fs_1.default.writeFileSync(overlayPath, JSON.stringify(admin, null, 2));
+            }
+            routes.push({
+                path: admin.api.operationId,
+                operationId: admin.api.operationId,
+                label: admin.meta?.intelligent?.label,
+                group: admin.meta?.intelligent?.group ?? null
+            });
+            viewDefaults.push({
+                key: admin.api.operationId,
+                view: 'cards'
+            });
+            if (admin.meta?.intelligent?.listOperationId) {
+                viewDefaults.push({
+                    key: admin.meta.intelligent.listOperationId,
+                    view: 'list'
+                });
+            }
+            operationIds.add(admin.api.operationId);
+            operationFileNames.add(toSafeFileName(admin.api.operationId));
+            console.log(`✨ Generated ${admin.api.operationId}`);
+        }
+    }
+    (0, logger_1.logStep)(`Screens generated: ${routes.length}`);
     /**
      * 4️⃣ Gera arquivo de rotas
      */
     const routesPath = path_1.default.join(generateUiRoot, 'routes.json');
     fs_1.default.writeFileSync(routesPath, JSON.stringify(routes, null, 2));
+    (0, logger_1.logDebug)(`Routes written: ${routesPath}`);
+    /**
+     * 4.3️⃣ Gera generateui-config.json (não sobrescreve)
+     */
+    const configPath = path_1.default.join(generateUiRoot, '..', '..', 'generateui-config.json');
+    let configPayload = null;
+    if (!fs_1.default.existsSync(configPath)) {
+        configPayload = {
+            appTitle: 'Generate UI',
+            defaultRoute: '',
+            menu: {
+                autoInject: true
+            },
+            views: {}
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configPayload, null, 2));
+        (0, logger_1.logDebug)(`Config created: ${configPath}`);
+    }
+    else {
+        try {
+            configPayload = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            configPayload = null;
+        }
+        (0, logger_1.logDebug)(`Config found: ${configPath}`);
+    }
+    if (configPayload && viewDefaults.length) {
+        configPayload.views = configPayload.views || {};
+        for (const entry of viewDefaults) {
+            if (!configPayload.views[entry.key]) {
+                configPayload.views[entry.key] = entry.view;
+            }
+        }
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configPayload, null, 2));
+        (0, logger_1.logDebug)(`Config views updated: ${configPath}`);
+    }
+    /**
+     * 4.1️⃣ Gera menu inicial (override possível via menu.overrides.json)
+     */
+    const menuPath = path_1.default.join(generateUiRoot, 'menu.json');
+    const menu = buildMenuFromRoutes(routes);
+    fs_1.default.writeFileSync(menuPath, JSON.stringify(menu, null, 2));
+    (0, logger_1.logDebug)(`Menu written: ${menuPath}`);
+    /**
+     * 4.2️⃣ Gera menu.overrides.json (não sobrescreve)
+     */
+    const menuOverridesPath = path_1.default.join(generateUiRoot, 'menu.overrides.json');
+    if (!fs_1.default.existsSync(menuOverridesPath)) {
+        fs_1.default.writeFileSync(menuOverridesPath, JSON.stringify(menu, null, 2));
+        (0, logger_1.logDebug)(`Menu overrides created: ${menuOverridesPath}`);
+    }
+    else {
+        (0, logger_1.logDebug)(`Menu overrides found: ${menuOverridesPath}`);
+    }
     /**
      * 5️⃣ Remove overlays órfãos (endpoint removido)
      */
@@ -135,30 +263,44 @@ async function generate(options) {
         .filter(file => file.endsWith('.screen.json'));
     for (const file of overlayFiles) {
         const opId = file.replace(/\.screen\.json$/, '');
-        if (!operationIds.has(opId)) {
+        if (!operationFileNames.has(opId)) {
             fs_1.default.rmSync(path_1.default.join(overlaysDir, file));
             if (options.debug) {
                 console.log(`✖ Removed overlay ${opId}`);
             }
         }
     }
-    if (permissions.features.maxGenerations > -1) {
-        (0, device_1.incrementFreeGeneration)();
-    }
     console.log('✔ Routes generated');
+    console.log('');
+    console.log('🎉 Next steps');
+    console.log('  1) Default full flow:');
+    console.log('     generate-ui generate');
+    console.log('  2) Advanced (schemas only):');
+    console.log('     generate-ui schema');
+    console.log('  3) Advanced (Angular only):');
+    console.log('     generate-ui angular');
+    console.log('  4) Customize screens in generate-ui/overlays/');
+    console.log('  5) Customize menu in generate-ui/menu.overrides.json (created once, never overwritten)');
+    console.log('  6) Edit generateui-config.json to set appTitle/defaultRoute/menu.autoInject/views');
+    console.log('');
+    (0, logger_1.logTip)('Run with --dev to see detailed logs and file paths.');
+}
+function normalizeSubscriptionReason(reason) {
+    if (typeof reason !== 'string')
+        return '';
+    const trimmed = reason.trim();
+    return trimmed;
 }
 function resolveGenerateUiRoot(projectRoot, output) {
     if (output) {
-        return path_1.default.resolve(process.cwd(), output);
+        return path_1.default.isAbsolute(output)
+            ? output
+            : path_1.default.resolve(process.cwd(), output);
     }
     const srcRoot = path_1.default.join(projectRoot, 'src');
     if (fs_1.default.existsSync(srcRoot)) {
         return path_1.default.join(srcRoot, 'generate-ui');
     }
-    const frontendSrcRoot = path_1.default.join(projectRoot, 'frontend', 'src');
-    if (fs_1.default.existsSync(frontendSrcRoot)) {
-        return path_1.default.join(frontendSrcRoot, 'generate-ui');
-    }
     return path_1.default.join(projectRoot, 'generate-ui');
 }
 function mergeParameters(pathParams, opParams) {
@@ -199,6 +341,194 @@ function buildOperationId(method, pathKey, usedOperationIds) {
     usedOperationIds.add(candidate);
     return candidate;
 }
+function inferRouteGroup(op, pathKey) {
+    const tag = Array.isArray(op?.tags) && op.tags.length
+        ? String(op.tags[0]).trim()
+        : '';
+    if (tag)
+        return tag;
+    const segment = String(pathKey || '')
+        .split('/')
+        .map(part => part.trim())
+        .filter(Boolean)
+        .find(part => !part.startsWith('{') && !part.endsWith('}'));
+    return segment ? segment : null;
+}
+function recordResourceOp(map, pathKey, method, operationId, op) {
+    const isItemPath = /\/{[^}]+}$/.test(pathKey);
+    const basePath = isItemPath
+        ? pathKey.replace(/\/{[^}]+}$/, '')
+        : pathKey;
+    const paramMatch = isItemPath
+        ? pathKey.match(/\/{([^}]+)}$/)
+        : null;
+    const idParam = paramMatch ? paramMatch[1] : null;
+    const tag = Array.isArray(op?.tags) && op.tags.length
+        ? String(op.tags[0]).trim()
+        : undefined;
+    const entry = map.get(basePath) || {
+        basePath
+    };
+    if (tag && !entry.tag)
+        entry.tag = tag;
+    if (idParam && !entry.idParam)
+        entry.idParam = idParam;
+    const payload = {
+        operationId,
+        method,
+        path: pathKey,
+        tag
+    };
+    if (!isItemPath && method === 'get')
+        entry.list = payload;
+    if (isItemPath && method === 'get')
+        entry.detail = payload;
+    if (isItemPath && (method === 'put' || method === 'patch')) {
+        entry.update = payload;
+    }
+    if (isItemPath && method === 'delete')
+        entry.remove = payload;
+    map.set(basePath, entry);
+}
+function buildAdminSchemas(resources, usedOperationIds, screenByOpId) {
+    const adminSchemas = [];
+    for (const resource of resources.values()) {
+        if (!resource.list)
+            continue;
+        const entity = inferEntityName(resource.basePath);
+        const baseId = toPascalCase(entity);
+        const baseOpId = `${baseId}Admin`;
+        let operationId = baseOpId;
+        let index = 2;
+        while (usedOperationIds.has(operationId)) {
+            operationId = `${baseOpId}${index}`;
+            index += 1;
+        }
+        usedOperationIds.add(operationId);
+        const label = `${toLabel(entity)} Admin`;
+        const group = resource.tag ? resource.tag : inferGroup(resource.basePath);
+        const listSchema = screenByOpId.get(resource.list.operationId);
+        const columns = listSchema?.data?.table?.columns &&
+            Array.isArray(listSchema.data.table.columns)
+            ? listSchema.data.table.columns
+            : [];
+        const responseFormat = listSchema?.response?.format === 'cards' ||
+            listSchema?.response?.format === 'raw' ||
+            listSchema?.response?.format === 'table'
+            ? listSchema.response.format
+            : columns.length > 0
+                ? 'table'
+                : null;
+        adminSchemas.push({
+            meta: {
+                intelligent: {
+                    kind: 'adminList',
+                    label,
+                    group,
+                    listOperationId: resource.list.operationId,
+                    detailOperationId: resource.detail?.operationId ?? null,
+                    updateOperationId: resource.update?.operationId ?? null,
+                    deleteOperationId: resource.remove?.operationId ?? null,
+                    idParam: resource.idParam ?? null
+                }
+            },
+            entity: toLabel(entity),
+            description: 'Smart admin list generated from collection endpoints.',
+            data: {
+                table: {
+                    columns
+                }
+            },
+            response: responseFormat
+                ? { format: responseFormat }
+                : undefined,
+            api: {
+                operationId,
+                method: 'get',
+                endpoint: resource.list.path
+            }
+        });
+    }
+    return adminSchemas;
+}
+function inferEntityName(pathKey) {
+    const segments = String(pathKey || '')
+        .split('/')
+        .filter(Boolean);
+    if (!segments.length)
+        return 'Resource';
+    const last = segments[segments.length - 1];
+    return last.replace(/[^a-zA-Z0-9]+/g, ' ');
+}
+function inferGroup(pathKey) {
+    const segment = String(pathKey || '')
+        .split('/')
+        .map(part => part.trim())
+        .filter(Boolean)[0];
+    return segment ? segment : null;
+}
+function buildMenuFromRoutes(routes) {
+    const groups = [];
+    const ungrouped = [];
+    const groupMap = new Map();
+    for (const route of routes) {
+        const item = {
+            id: route.operationId,
+            label: toLabel(route.label || route.operationId),
+            route: route.path
+        };
+        const rawGroup = route.group ? String(route.group) : '';
+        if (!rawGroup) {
+            ungrouped.push(item);
+            continue;
+        }
+        const groupId = toKebab(rawGroup);
+        let group = groupMap.get(groupId);
+        if (!group) {
+            group = {
+                id: groupId,
+                label: toLabel(rawGroup),
+                items: []
+            };
+            groupMap.set(groupId, group);
+            groups.push(group);
+        }
+        group.items.push(item);
+    }
+    return {
+        groups,
+        ungrouped
+    };
+}
+function toKebab(value) {
+    return String(value)
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[_\s]+/g, '-')
+        .toLowerCase();
+}
+function toLabel(value) {
+    return stripDiacritics(String(value))
+        .replace(/[_-]/g, ' ')
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/\b\w/g, char => char.toUpperCase());
+}
+function toSafeFileName(value) {
+    return String(value)
+        .replace(/[\\/]/g, '-')
+        .replace(/\s+/g, '-');
+}
+function stripDiacritics(value) {
+    return value
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '');
+}
+function toPascalCase(value) {
+    return String(value)
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map(part => part[0].toUpperCase() + part.slice(1))
+        .join('');
+}
 function httpVerbToPrefix(verb) {
     switch (verb) {
         case 'get':