@eide/uniformgen 0.1.0

package/dist/cli.js

@@ -0,0 +1,563 @@
+#!/usr/bin/env node
+// Load environment variables from .env.local
+import { config } from 'dotenv';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Load .env.local from package root
+config({ path: resolve(__dirname, '../.env.local') });
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { join } from 'path';
+import { loadConfig } from './config/load-config.js';
+import { getSettings } from './config/settings.js';
+import { fetchEntityModels, fetchContextDefinitions, } from './fetcher/fetch-schemas.js';
+import { generateEntityModelTypes, generateEntityModelsIndex, } from './generators/types/entity-models.js';
+import { generateFieldTypesFile } from './generators/types/field-types.js';
+import { generateHooksFile } from './generators/types/hooks.js';
+import { generateConfigFile } from './generators/types/config.js';
+import { generateEntityModelDocuments } from './generators/documents/entity-models.js';
+import { generateAgnosticHooks, generateAgnosticHooksIndex, generateReactHooks, generateReactHooksIndex, generateRemixHooks, generateRemixHooksIndex, } from './generators/hooks/index.js';
+import { generatePlatformResolveReact, generatePlatformResolveRemix, generatePlatformResolveIndexReact, generatePlatformResolveIndexRemix, } from './generators/resolve/index.js';
+// Phase 13: Admin layer generators
+import { generateAdminHooksReact, generateAdminHooksRemix, generateAdminHooksIndexReact, generateAdminHooksIndexRemix, } from './generators/admin/index.js';
+// Phase 13: CMS layer generators
+import { getRoutableModels, generateCmsTypes, generateResolveRouteReact as generateCmsRouteReact, generateResolveRouteRemix as generateCmsRouteRemix, generateCmsIndexReact, generateCmsIndexRemix, } from './generators/cms/index.js';
+import { generateModelFilters, generateFiltersIndex, } from './generators/filters/index.js';
+import { generateContextsFile, generateEmptyContextsFile, } from './generators/contexts/index.js';
+import { writeFiles } from './writer/write-files.js';
+import { login } from './commands/login.js';
+import { logout } from './commands/logout.js';
+import { selectProject } from './commands/select-project.js';
+import { whoami } from './commands/whoami.js';
+import { setup } from './commands/setup.js';
+import { push } from './commands/push.js';
+import { init } from './commands/init.js';
+import { sync } from './commands/sync.js';
+import { scaffold } from './commands/scaffold.js';
+import { seed } from './commands/seed.js';
+import { defaultConfig } from './config/types.js';
+// Use UNIFORMGEN_API_URL env var if set, otherwise fall back to defaultConfig
+const apiUrlDefault = process.env.UNIFORMGEN_API_URL || defaultConfig.apiUrl;
+const program = new Command();
+program
+    .name('uniformgen')
+    .description('Type-safe code generator for EIDE CMS')
+    .version('0.1.0');
+// ============================================================================
+// Authentication Commands
+// ============================================================================
+program
+    .command('login')
+    .description('Authenticate via browser OAuth')
+    .option('--api-url <url>', 'API endpoint URL', apiUrlDefault)
+    .action(async (options) => {
+    try {
+        await login({ apiUrl: options.apiUrl });
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program
+    .command('logout')
+    .description('Clear stored credentials')
+    .action(async () => {
+    try {
+        await logout();
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program
+    .command('select-project')
+    .description('Choose which project to work with')
+    .option('--api-url <url>', 'API endpoint URL', apiUrlDefault)
+    .option('--project-id <id>', 'Project ID to select directly')
+    .action(async (options) => {
+    try {
+        await selectProject({
+            apiUrl: options.apiUrl,
+            projectId: options.projectId,
+        });
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program
+    .command('whoami')
+    .description('Show current authentication status')
+    .action(async () => {
+    try {
+        await whoami();
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program
+    .command('setup')
+    .description('Configure code generation preferences (framework, output paths)')
+    .action(async () => {
+    try {
+        await setup();
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================================
+// Generation Commands
+// ============================================================================
+program
+    .command('pull')
+    .description('Fetch entity models and generate types')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('--api-url <url>', 'API endpoint URL')
+    .option('--project-key <key>', 'Project API key')
+    .option('--out <dir>', 'Output directory')
+    .option('--no-prettier', 'Disable Prettier formatting')
+    .option('--dry-run', 'Show what would be generated without writing files')
+    .option('--only <models>', 'Only generate for specific entity models (comma-separated keys)')
+    .option('--include-inline', 'Include inline-only entity models')
+    .option('-v, --verbose', 'Enable verbose logging')
+    .action(async (options) => {
+    const spinner = ora();
+    try {
+        // Load configuration
+        spinner.start('Loading configuration...');
+        const config = await loadConfig(options.config, process.cwd());
+        // Override config with CLI options
+        if (options.apiUrl)
+            config.apiUrl = options.apiUrl;
+        if (options.projectKey)
+            config.projectKey = options.projectKey;
+        if (options.out) {
+            config.output = {
+                types: join(options.out, 'types'),
+                documents: join(options.out, 'documents'),
+                hooks: join(options.out, 'hooks'),
+            };
+        }
+        if (options.prettier === false)
+            config.prettier = false;
+        spinner.succeed('Configuration loaded');
+        if (options.verbose) {
+            console.log(chalk.gray('Config:'), config);
+        }
+        // Fetch entity models from API
+        spinner.start(`Fetching entity models from ${config.apiUrl}...`);
+        let entityModels = await fetchEntityModels(config.apiUrl, config.accessToken, config.tenantId, config.projectId, {
+            includeInline: options.includeInline ?? true,
+        });
+        // Filter to specific models if --only provided
+        if (options.only) {
+            const onlyKeys = options.only.split(',').map((k) => k.trim());
+            entityModels = entityModels.filter((m) => onlyKeys.includes(m.key));
+        }
+        // Filter to only models with records: true (can create standalone records)
+        const recordModels = entityModels.filter((m) => m.modes.records);
+        spinner.succeed(`Fetched ${entityModels.length} entity models (${recordModels.length} with records)`);
+        if (options.verbose) {
+            console.log(chalk.gray('Entity models:'));
+            for (const model of entityModels) {
+                const tags = [];
+                if (model.modes.records)
+                    tags.push('records');
+                if (model.modes.inline)
+                    tags.push('inline');
+                console.log(chalk.gray(`  - ${model.key} (${tags.join(', ')})`));
+            }
+        }
+        // Fetch context definitions (values are fetched at runtime, not generate time)
+        spinner.start('Fetching context definitions...');
+        const contextDefinitions = await fetchContextDefinitions(config.apiUrl, config.accessToken, config.tenantId, config.projectId);
+        // Map to generation format (just definitions, values fetched at runtime)
+        const contextsForGeneration = contextDefinitions.map((definition) => ({ definition }));
+        spinner.succeed(contextDefinitions.length > 0
+            ? `Fetched ${contextDefinitions.length} context definitions`
+            : 'No context definitions found (using defaults)');
+        if (options.verbose && contextDefinitions.length > 0) {
+            console.log(chalk.gray('Contexts (values fetched at runtime):'));
+            for (const ctx of contextsForGeneration) {
+                console.log(chalk.gray(`  - ${ctx.definition.key} (linked to ${ctx.definition.entityModelKey})`));
+            }
+        }
+        // Generate files
+        const files = [];
+        // Generate base type files
+        spinner.start('Generating type definitions...');
+        files.push({
+            path: join(config.output.types, 'field-types.ts'),
+            content: generateFieldTypesFile(),
+        });
+        files.push({
+            path: join(config.output.types, 'hooks.ts'),
+            content: generateHooksFile(),
+        });
+        files.push({
+            path: join(config.output.types, 'config.ts'),
+            content: generateConfigFile(),
+        });
+        // Generate contexts file (with runtime query support) - in hooks folder
+        files.push({
+            path: join(config.output.hooks, 'contexts.ts'),
+            content: contextsForGeneration.length > 0
+                ? generateContextsFile(contextsForGeneration)
+                : generateEmptyContextsFile(),
+        });
+        spinner.succeed('Generated base type definitions');
+        // Generate entity model types (for all models - both records and inline)
+        if (entityModels.length > 0) {
+            const inlineOnlyModels = entityModels.filter((m) => m.modes.inline && !m.modes.records);
+            spinner.start(`Generating ${entityModels.length} entity models (${recordModels.length} configs + ${inlineOnlyModels.length} inline types)...`);
+            const modelsDir = join(config.output.types, 'models');
+            for (const model of entityModels) {
+                files.push({
+                    path: join(modelsDir, `${model.key}.ts`),
+                    content: generateEntityModelTypes(model, entityModels),
+                });
+            }
+            // Generate index for all types
+            files.push({
+                path: join(modelsDir, 'index.ts'),
+                content: generateEntityModelsIndex(entityModels),
+            });
+            spinner.succeed(`Generated ${entityModels.length} entity models (${recordModels.length} configs + ${inlineOnlyModels.length} inline types)`);
+        }
+        // Generate GraphQL documents (only for models with publicApi: true)
+        const publicApiModels = recordModels.filter((m) => m.modes.publicApi);
+        if (publicApiModels.length > 0) {
+            spinner.start(`Generating GraphQL documents for ${publicApiModels.length} public API models...`);
+            for (const model of publicApiModels) {
+                files.push({
+                    path: join(config.output.documents, `${model.key}.graphql`),
+                    content: generateEntityModelDocuments(model),
+                });
+            }
+            spinner.succeed(`Generated GraphQL documents for ${publicApiModels.length} public API models`);
+        }
+        // Generate typed hooks based on framework setting
+        const settings = await getSettings();
+        const framework = config.framework || settings.framework || 'agnostic';
+        if (publicApiModels.length > 0) {
+            spinner.start(`Generating ${framework} hooks for ${publicApiModels.length} models...`);
+            const hooksDir = config.output.hooks;
+            let generateHook;
+            let generateIndex;
+            switch (framework) {
+                case 'react':
+                    generateHook = generateReactHooks;
+                    generateIndex = generateReactHooksIndex;
+                    break;
+                case 'remix':
+                    generateHook = generateRemixHooks;
+                    generateIndex = generateRemixHooksIndex;
+                    break;
+                default:
+                    generateHook = generateAgnosticHooks;
+                    generateIndex = generateAgnosticHooksIndex;
+            }
+            for (const model of publicApiModels) {
+                const hookContent = generateHook(model, entityModels);
+                if (hookContent) {
+                    files.push({
+                        path: join(hooksDir, `${model.key}.ts`),
+                        content: hookContent,
+                    });
+                }
+            }
+            files.push({
+                path: join(hooksDir, 'index.ts'),
+                content: generateIndex(publicApiModels),
+            });
+            spinner.succeed(`Generated ${framework} hooks for ${publicApiModels.length} models`);
+        }
+        // ========================================================================
+        // Phase 13: Generate layered API structure
+        // ========================================================================
+        // Phase 13: Generate admin hooks (CRUD, versioning)
+        if (publicApiModels.length > 0 && framework !== 'agnostic') {
+            spinner.start(`Generating ${framework} admin hooks for ${publicApiModels.length} models...`);
+            const adminDir = join(config.output.hooks, 'admin');
+            const generateAdmin = framework === 'react' ? generateAdminHooksReact : generateAdminHooksRemix;
+            const generateAdminIndex = framework === 'react' ? generateAdminHooksIndexReact : generateAdminHooksIndexRemix;
+            for (const model of publicApiModels) {
+                const adminContent = generateAdmin(model, entityModels);
+                if (adminContent) {
+                    files.push({
+                        path: join(adminDir, `${model.key}.ts`),
+                        content: adminContent,
+                    });
+                }
+            }
+            files.push({
+                path: join(adminDir, 'index.ts'),
+                content: generateAdminIndex(publicApiModels),
+            });
+            spinner.succeed(`Generated ${framework} admin hooks for ${publicApiModels.length} models`);
+        }
+        // Phase 13: Generate platform resolve hooks (clean, no CMS features)
+        if (publicApiModels.length > 0 && framework !== 'agnostic') {
+            spinner.start(`Generating ${framework} platform resolve hooks for ${publicApiModels.length} models...`);
+            const platformResolveDir = join(config.output.hooks, 'resolve');
+            const generatePlatformResolve = framework === 'react' ? generatePlatformResolveReact : generatePlatformResolveRemix;
+            const generatePlatformIndex = framework === 'react' ? generatePlatformResolveIndexReact : generatePlatformResolveIndexRemix;
+            for (const model of publicApiModels) {
+                const resolveContent = generatePlatformResolve(model, entityModels);
+                if (resolveContent) {
+                    files.push({
+                        path: join(platformResolveDir, `${model.key}.ts`),
+                        content: resolveContent,
+                    });
+                }
+            }
+            files.push({
+                path: join(platformResolveDir, 'index.ts'),
+                content: generatePlatformIndex(publicApiModels),
+            });
+            spinner.succeed(`Generated ${framework} platform resolve hooks for ${publicApiModels.length} models`);
+        }
+        // Phase 13: Generate CMS hooks (only if cms.enabled models exist)
+        const routableModels = getRoutableModels(entityModels);
+        if (routableModels.length > 0 && framework !== 'agnostic') {
+            spinner.start(`Generating ${framework} CMS hooks for ${routableModels.length} routable models...`);
+            const cmsDir = join(config.output.hooks, 'cms');
+            const generateCmsRoute = framework === 'react' ? generateCmsRouteReact : generateCmsRouteRemix;
+            const generateCmsIndex = framework === 'react' ? generateCmsIndexReact : generateCmsIndexRemix;
+            // Generate CMS types
+            files.push({
+                path: join(cmsDir, 'types.ts'),
+                content: generateCmsTypes(),
+            });
+            // Generate resolveRoute hook/function
+            files.push({
+                path: join(cmsDir, 'route.ts'),
+                content: generateCmsRoute(routableModels),
+            });
+            // Generate CMS index
+            files.push({
+                path: join(cmsDir, 'index.ts'),
+                content: generateCmsIndex(entityModels),
+            });
+            spinner.succeed(`Generated ${framework} CMS hooks for ${routableModels.length} routable models`);
+            if (options.verbose) {
+                console.log(chalk.gray('Routable models (cms.enabled = true):'));
+                for (const model of routableModels) {
+                    console.log(chalk.gray(`  - ${model.key}`));
+                }
+            }
+        }
+        else if (options.verbose && framework !== 'agnostic') {
+            console.log(chalk.gray('No routable models found - skipping CMS hooks generation'));
+        }
+        // Generate typed filters
+        if (publicApiModels.length > 0) {
+            spinner.start(`Generating typed filters for ${publicApiModels.length} models...`);
+            const filtersDir = join(config.output.types, '..', 'filters');
+            for (const model of publicApiModels) {
+                const filterContent = generateModelFilters(model, entityModels);
+                if (filterContent) {
+                    files.push({
+                        path: join(filtersDir, `${model.key}.ts`),
+                        content: filterContent,
+                    });
+                }
+            }
+            files.push({
+                path: join(filtersDir, 'index.ts'),
+                content: generateFiltersIndex(publicApiModels),
+            });
+            spinner.succeed(`Generated typed filters for ${publicApiModels.length} models`);
+        }
+        // Generate main index
+        files.push({
+            path: join(config.output.types, 'index.ts'),
+            content: `/**
+ * Generated types for EIDE project
+ *
+ * @generated by UniformGen - DO NOT EDIT MANUALLY
+ */
+
+export * from './field-types.js';
+export * from './hooks.js';
+export * from './config.js';
+export * from './contexts.js';
+${entityModels.length > 0 ? "export * from './models/index.js';" : ''}
+`,
+        });
+        // Dry run
+        if (options.dryRun) {
+            console.log(chalk.cyan('\nDry run - files that would be generated:'));
+            files.forEach((f) => console.log(chalk.gray(`  - ${f.path}`)));
+            console.log(chalk.cyan(`\nTotal: ${files.length} files`));
+            return;
+        }
+        // Write files
+        spinner.start(`Writing ${files.length} files...`);
+        await writeFiles(files, config.prettier);
+        spinner.succeed(`Generated ${files.length} files`);
+        console.log(chalk.green('\n✓ Code generation complete!'));
+        console.log(chalk.gray(`  Output: ${config.output.types}`));
+    }
+    catch (error) {
+        spinner.fail('Generation failed');
+        console.error(chalk.red('\nError:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================================
+// Schema Management Commands
+// ============================================================================
+program
+    .command('push')
+    .description('Sync local schema files to platform')
+    .option('--api-url <url>', 'API endpoint URL', apiUrlDefault)
+    .option('--schemas <dir>', 'Directory containing .schema.ts files', './schemas')
+    .option('--pattern <pattern>', 'Glob pattern for schema files', '**/*.schema.ts')
+    .option('--dry-run', 'Preview changes without applying')
+    .option('--publish', 'Publish schemas after pushing')
+    .action(async (options) => {
+    try {
+        await push({
+            apiUrl: options.apiUrl,
+            schemasDir: options.schemas,
+            pattern: options.pattern,
+            dryRun: options.dryRun,
+            publish: options.publish,
+        });
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program
+    .command('init')
+    .description('Generate local schema files from platform schemas')
+    .option('--api-url <url>', 'API endpoint URL', apiUrlDefault)
+    .option('--schemas <dir>', 'Output directory for schema files', './schemas')
+    .option('--overwrite', 'Overwrite existing schema files')
+    .action(async (options) => {
+    try {
+        await init({
+            apiUrl: options.apiUrl,
+            schemasDir: options.schemas,
+            overwrite: options.overwrite,
+        });
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program
+    .command('sync')
+    .description('Push local schemas then pull generated types')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('--api-url <url>', 'API endpoint URL', apiUrlDefault)
+    .option('--schemas <dir>', 'Directory containing .schema.ts files', './schemas')
+    .option('--pattern <pattern>', 'Glob pattern for schema files', '**/*.schema.ts')
+    .option('--publish', 'Publish schemas after pushing')
+    .action(async (options) => {
+    try {
+        await sync({
+            apiUrl: options.apiUrl,
+            schemasDir: options.schemas,
+            pattern: options.pattern,
+            publish: options.publish,
+            config: options.config,
+        });
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================================
+// Component Scaffolding Commands
+// ============================================================================
+program
+    .command('scaffold')
+    .description('Generate React component stubs for @eide/foir-renderer')
+    .option('--api-url <url>', 'API endpoint URL', apiUrlDefault)
+    .option('--components <dir>', 'Output directory for components', './src/components/foir')
+    .option('--models <models>', 'Only scaffold specific models (comma-separated keys)')
+    .option('--overwrite', 'Overwrite existing component files')
+    .option('--framework <framework>', 'Framework: react, remix, next', 'react')
+    .option('-c, --config <path>', 'Path to config file')
+    .action(async (options) => {
+    try {
+        await scaffold({
+            apiUrl: options.apiUrl,
+            componentsDir: options.components,
+            models: options.models,
+            overwrite: options.overwrite,
+            framework: options.framework,
+            config: options.config,
+        });
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================================
+// Content Seeding Commands
+// ============================================================================
+program
+    .command('seed')
+    .description('Seed content data from local JSON/YAML files')
+    .option('--api-url <url>', 'API endpoint URL', apiUrlDefault)
+    .option('--seed <dir>', 'Directory containing seed files', './seed')
+    .option('--pattern <pattern>', 'Filter files by pattern')
+    .option('--publish', 'Publish records after creating')
+    .option('--upsert', 'Update existing records instead of skipping')
+    .option('--dry-run', 'Preview changes without applying')
+    .option('-c, --config <path>', 'Path to config file')
+    .action(async (options) => {
+    try {
+        await seed({
+            apiUrl: options.apiUrl,
+            seedDir: options.seed,
+            pattern: options.pattern,
+            publish: options.publish,
+            upsert: options.upsert,
+            dryRun: options.dryRun,
+            config: options.config,
+        });
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// Default command (no subcommand = pull)
+program
+    .option('-c, --config <path>', 'Path to config file')
+    .option('--api-url <url>', 'API endpoint URL')
+    .option('--project-key <key>', 'Project API key')
+    .option('--out <dir>', 'Output directory')
+    .option('--no-prettier', 'Disable Prettier formatting')
+    .option('--dry-run', 'Show what would be generated without writing files')
+    .option('--only <models>', 'Only generate for specific entity models (comma-separated keys)')
+    .option('--include-inline', 'Include inline-only entity models')
+    .option('-v, --verbose', 'Enable verbose logging')
+    .action(async (_options, command) => {
+    // If no subcommand and has arguments, run pull
+    if (command.args.length === 0) {
+        await command.parent?.commands
+            .find((c) => c.name() === 'pull')
+            ?.parseAsync(process.argv.slice(2), { from: 'user' });
+    }
+});
+program.parse();

package/dist/commands/init.d.ts

@@ -0,0 +1,11 @@
+interface InitOptions {
+    apiUrl: string;
+    schemasDir: string;
+    overwrite?: boolean;
+}
+/**
+ * Init command - generate local schema files from platform schemas
+ */
+export declare function init(options: InitOptions): Promise<void>;
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAOA,UAAU,WAAW;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAkED;;GAEG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CA8D9D"}