@eide/uniformgen 0.1.0

package/dist/commands/seed.js

@@ -0,0 +1,380 @@
+/**
+ * Seed Command
+ *
+ * Seeds content data to a Foir project from local JSON/YAML files.
+ * Useful for bootstrapping starter content in templates.
+ */
+import chalk from 'chalk';
+import ora from 'ora';
+import { readFile, readdir, stat } from 'fs/promises';
+import { join, extname, basename } from 'path';
+import { loadConfig } from '../config/load-config.js';
+/**
+ * Get the GraphQL endpoint URL
+ */
+function getGraphQLEndpoint(apiUrl) {
+    const base = apiUrl.replace(/\/$/, '').replace(/\/graphql$/, '');
+    return `${base}/graphql`;
+}
+/**
+ * Create a simple GraphQL client
+ */
+function createClient(apiUrl, accessToken, tenantId, projectId) {
+    const endpoint = getGraphQLEndpoint(apiUrl);
+    return {
+        async request(query, variables) {
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+            if (accessToken) {
+                headers['Authorization'] = `Bearer ${accessToken}`;
+            }
+            // Add tenant/project context headers for internal API
+            if (tenantId) {
+                headers['x-tenant-id'] = tenantId;
+            }
+            if (projectId) {
+                headers['x-project-id'] = projectId;
+            }
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ query, variables }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const result = await response.json();
+            if (result.errors && result.errors.length > 0) {
+                throw new Error(result.errors.map((e) => e.message).join(', '));
+            }
+            return result.data;
+        },
+    };
+}
+// GraphQL mutations (Internal API)
+const CREATE_ENTITY_RECORD_MUTATION = `
+  mutation CreateEntityRecord($input: CreateEntityRecordInput!) {
+    createEntityRecord(input: $input) {
+      id
+      modelKey
+      naturalKey
+      currentVersionId
+      variants(limit: 1) {
+        items {
+          id
+          currentVersionId
+        }
+      }
+    }
+  }
+`;
+const PUBLISH_VERSION_MUTATION = `
+  mutation PublishEntityRecordVersion($versionId: ID!) {
+    publishEntityRecordVersion(versionId: $versionId) {
+      id
+      publishedVersionId
+    }
+  }
+`;
+const CREATE_ROUTE_MUTATION = `
+  mutation CreateRoute($input: CreateRouteInput!) {
+    createRoute(input: $input) {
+      id
+      path
+    }
+  }
+`;
+// Query to find existing record by natural key
+const GET_ENTITY_RECORD_QUERY = `
+  query GetEntityRecord($modelKey: String!, $naturalKey: String!) {
+    entityRecord(modelKey: $modelKey, naturalKey: $naturalKey) {
+      id
+      naturalKey
+      currentVersionId
+      variants(limit: 1) {
+        items {
+          id
+          currentVersionId
+          isDefault
+        }
+      }
+    }
+  }
+`;
+// Mutation to create a new version (for upsert)
+const CREATE_VERSION_MUTATION = `
+  mutation CreateEntityRecordVersion($input: CreateEntityRecordVersionInput!) {
+    createEntityRecordVersion(input: $input) {
+      id
+      versionNumber
+    }
+  }
+`;
+// Mutation to update record metadata
+const UPDATE_ENTITY_RECORD_MUTATION = `
+  mutation UpdateEntityRecord($id: ID!, $input: UpdateEntityRecordInput!) {
+    updateEntityRecord(id: $id, input: $input) {
+      id
+      naturalKey
+    }
+  }
+`;
+/**
+ * Parse a seed file (JSON or YAML)
+ */
+async function parseSeedFile(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    const content = await readFile(filePath, 'utf-8');
+    if (ext === '.json') {
+        return JSON.parse(content);
+    }
+    if (ext === '.yaml' || ext === '.yml') {
+        // Simple YAML parsing for common cases
+        // For full YAML support, users can install js-yaml
+        try {
+            // Dynamic import for optional js-yaml dependency
+            // @ts-expect-error - js-yaml is an optional peer dependency
+            const jsYaml = await import('js-yaml');
+            const loadFn = jsYaml.load || jsYaml.default?.load;
+            if (!loadFn)
+                throw new Error('js-yaml load function not found');
+            return loadFn(content);
+        }
+        catch {
+            console.warn(chalk.yellow(`  Warning: js-yaml not installed, skipping ${filePath}`));
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Get all seed files from a directory
+ */
+async function getSeedFiles(seedDir, pattern) {
+    const files = [];
+    async function scanDir(dir) {
+        const entries = await readdir(dir);
+        for (const entry of entries) {
+            const fullPath = join(dir, entry);
+            const stats = await stat(fullPath);
+            if (stats.isDirectory()) {
+                await scanDir(fullPath);
+            }
+            else if (stats.isFile()) {
+                const ext = extname(entry).toLowerCase();
+                if (['.json', '.yaml', '.yml'].includes(ext)) {
+                    // Apply pattern filter if provided
+                    if (!pattern || entry.includes(pattern) || basename(entry, ext).includes(pattern)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        }
+    }
+    await scanDir(seedDir);
+    return files.sort();
+}
+/**
+ * Main seed function
+ */
+export async function seed(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 (!config.apiUrl) {
+            throw new Error('API URL not configured. Run `uniformgen setup` or provide --api-url');
+        }
+        spinner.succeed('Configuration loaded');
+        // Create GraphQL client with tenant/project context
+        const client = createClient(config.apiUrl, config.accessToken, config.tenantId, config.projectId);
+        // Find seed files
+        spinner.start(`Scanning ${options.seedDir} for seed files...`);
+        const seedFiles = await getSeedFiles(options.seedDir, options.pattern);
+        spinner.succeed(`Found ${seedFiles.length} seed files`);
+        if (seedFiles.length === 0) {
+            console.log(chalk.yellow('\nNo seed files found.'));
+            console.log(chalk.gray('Create .json or .yaml files in the seed directory.'));
+            return;
+        }
+        // Process each seed file
+        let totalCreated = 0;
+        let totalUpdated = 0;
+        let totalPublished = 0;
+        let totalRoutes = 0;
+        let totalSkipped = 0;
+        let totalErrors = 0;
+        for (const filePath of seedFiles) {
+            const relativePath = filePath.replace(options.seedDir, '').replace(/^\//, '');
+            spinner.start(`Processing ${relativePath}...`);
+            const seedData = await parseSeedFile(filePath);
+            if (!seedData) {
+                spinner.warn(`Skipped ${relativePath} (unsupported format)`);
+                totalSkipped++;
+                continue;
+            }
+            const { modelKey, records } = seedData;
+            if (!modelKey || !records || !Array.isArray(records)) {
+                spinner.warn(`Skipped ${relativePath} (invalid format - needs modelKey and records)`);
+                totalSkipped++;
+                continue;
+            }
+            spinner.text = `Processing ${relativePath} (${records.length} records)...`;
+            for (const record of records) {
+                if (!record.naturalKey || !record.data) {
+                    console.log(chalk.yellow(`  Skipping record without naturalKey or data`));
+                    totalSkipped++;
+                    continue;
+                }
+                try {
+                    if (options.dryRun) {
+                        console.log(chalk.gray(`  [dry-run] Would ${options.upsert ? 'upsert' : 'create'} ${modelKey}/${record.naturalKey}`));
+                        totalCreated++;
+                        continue;
+                    }
+                    let existingRecord = null;
+                    if (options.upsert) {
+                        try {
+                            const result = await client.request(GET_ENTITY_RECORD_QUERY, {
+                                modelKey,
+                                naturalKey: record.naturalKey,
+                            });
+                            existingRecord = result.entityRecord;
+                        }
+                        catch {
+                            // Record doesn't exist, will create new
+                            existingRecord = null;
+                        }
+                    }
+                    let entityId;
+                    let versionId = null;
+                    if (existingRecord !== null && options.upsert) {
+                        // UPDATE existing record
+                        const existing = existingRecord;
+                        entityId = existing.id;
+                        // Update metadata if provided
+                        if (record.metadata) {
+                            await client.request(UPDATE_ENTITY_RECORD_MUTATION, {
+                                id: entityId,
+                                input: { metadata: record.metadata },
+                            });
+                        }
+                        // Get the default variant ID
+                        const defaultVariant = existing.variants.items.find((v) => v.isDefault) || existing.variants.items[0];
+                        if (defaultVariant) {
+                            // Create a new version with the seed content
+                            const versionResult = await client.request(CREATE_VERSION_MUTATION, {
+                                input: {
+                                    variantId: defaultVariant.id,
+                                    content: record.data,
+                                    changeDescription: 'Updated via seed --upsert',
+                                },
+                            });
+                            versionId = versionResult.createEntityRecordVersion.id;
+                        }
+                        totalUpdated++;
+                        console.log(chalk.blue(`  ↻ ${modelKey}/${record.naturalKey} (updated)`));
+                    }
+                    else {
+                        // CREATE new record
+                        const createResult = await client.request(CREATE_ENTITY_RECORD_MUTATION, {
+                            input: {
+                                modelKey,
+                                naturalKey: record.naturalKey,
+                                metadata: record.metadata,
+                                content: record.data,
+                            },
+                        });
+                        entityId = createResult.createEntityRecord.id;
+                        versionId =
+                            createResult.createEntityRecord.currentVersionId ??
+                                createResult.createEntityRecord.variants.items[0]?.currentVersionId ?? null;
+                        totalCreated++;
+                        console.log(chalk.green(`  ✓ ${modelKey}/${record.naturalKey}`));
+                    }
+                    // Create route if routing config provided
+                    if (record.routing?.path) {
+                        try {
+                            await client.request(CREATE_ROUTE_MUTATION, {
+                                input: {
+                                    path: record.routing.path,
+                                    entityRecordId: entityId,
+                                    priority: record.routing.priority ?? 0,
+                                },
+                            });
+                            totalRoutes++;
+                        }
+                        catch (_routeError) {
+                            // Route creation is optional, log but don't fail
+                            console.log(chalk.yellow(`  Warning: Could not create route for ${record.naturalKey}`));
+                        }
+                    }
+                    // Publish if requested
+                    if (options.publish && versionId) {
+                        try {
+                            await client.request(PUBLISH_VERSION_MUTATION, {
+                                versionId,
+                            });
+                            totalPublished++;
+                        }
+                        catch (_publishError) {
+                            console.log(chalk.yellow(`  Warning: Could not publish ${record.naturalKey}`));
+                        }
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : 'Unknown error';
+                    if (message.includes('already exists') || message.includes('duplicate')) {
+                        if (options.upsert) {
+                            console.log(chalk.red(`  ✗ ${modelKey}/${record.naturalKey}: Failed to upsert - ${message}`));
+                            totalErrors++;
+                        }
+                        else {
+                            console.log(chalk.gray(`  ○ ${modelKey}/${record.naturalKey} (already exists, use --upsert to update)`));
+                            totalSkipped++;
+                        }
+                    }
+                    else {
+                        console.log(chalk.red(`  ✗ ${modelKey}/${record.naturalKey}: ${message}`));
+                        totalErrors++;
+                    }
+                }
+            }
+            spinner.succeed(`Processed ${relativePath}`);
+        }
+        // Summary
+        console.log('');
+        console.log(chalk.bold('Seed Summary'));
+        console.log('─'.repeat(40));
+        console.log(chalk.green(`  Created:   ${totalCreated} records`));
+        if (totalUpdated > 0) {
+            console.log(chalk.blue(`  Updated:   ${totalUpdated} records`));
+        }
+        if (options.publish) {
+            console.log(chalk.green(`  Published: ${totalPublished} records`));
+        }
+        if (totalRoutes > 0) {
+            console.log(chalk.green(`  Routes:    ${totalRoutes} created`));
+        }
+        if (totalSkipped > 0) {
+            console.log(chalk.yellow(`  Skipped:   ${totalSkipped} records`));
+        }
+        if (totalErrors > 0) {
+            console.log(chalk.red(`  Errors:    ${totalErrors} records`));
+        }
+        if (options.dryRun) {
+            console.log('');
+            console.log(chalk.cyan('This was a dry run. No changes were made.'));
+            console.log(chalk.gray('Remove --dry-run to actually seed data.'));
+        }
+    }
+    catch (error) {
+        spinner.fail('Seeding failed');
+        throw error;
+    }
+}

package/dist/commands/select-project.d.ts

@@ -0,0 +1,10 @@
+interface SelectProjectOptions {
+    apiUrl: string;
+    projectId?: string;
+}
+/**
+ * Select project command - choose which project to work with
+ */
+export declare function selectProject(options: SelectProjectOptions): Promise<void>;
+export {};
+//# sourceMappingURL=select-project.d.ts.map

package/dist/commands/select-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-project.d.ts","sourceRoot":"","sources":["../../src/commands/select-project.ts"],"names":[],"mappings":"AA2BA,UAAU,oBAAoB;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA+QD;;GAEG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,IAAI,CAAC,CA2Ff"}

package/dist/commands/select-project.js

@@ -0,0 +1,277 @@
+import inquirer from 'inquirer';
+import { getCredentials, updateCredentials } from '../auth/credentials.js';
+const CLI_API_KEY_NAME = 'UniformGen CLI';
+/**
+ * Get the internal GraphQL endpoint URL from the base API URL
+ */
+function getInternalGraphQLEndpoint(apiUrl) {
+    const base = apiUrl.replace(/\/$/, '').replace(/\/graphql$/, '');
+    return `${base}/graphql`;
+}
+/**
+ * Fetch session context with available tenants and projects
+ * Uses the same pattern as the admin app - no tenant context required
+ */
+async function fetchSessionContext(apiUrl, accessToken) {
+    const response = await fetch(getInternalGraphQLEndpoint(apiUrl), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+        },
+        body: JSON.stringify({
+            query: `
+        query GetSessionContext {
+          sessionContext {
+            tenantId
+            projectId
+            availableTenants {
+              id
+              name
+            }
+            availableProjects {
+              id
+              name
+              tenantId
+            }
+          }
+        }
+      `,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch session context: ${response.statusText}`);
+    }
+    const result = (await response.json());
+    if (result.errors && result.errors.length > 0) {
+        throw new Error(`GraphQL error: ${result.errors[0]?.message ?? 'Unknown error'}`);
+    }
+    if (!result.data?.sessionContext) {
+        throw new Error('No session context returned');
+    }
+    return result.data.sessionContext;
+}
+/**
+ * Fetch API keys for a project
+ */
+async function fetchApiKeys(apiUrl, accessToken, projectId, tenantId) {
+    const response = await fetch(getInternalGraphQLEndpoint(apiUrl), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+            'x-tenant-id': tenantId,
+            'x-project-id': projectId,
+        },
+        body: JSON.stringify({
+            query: `
+        query ListApiKeys {
+          listApiKeys(includeInactive: false, limit: 100) {
+            apiKeys {
+              id
+              name
+              isActive
+            }
+          }
+        }
+      `,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch API keys: ${response.statusText}`);
+    }
+    const result = (await response.json());
+    if (result.errors && result.errors.length > 0) {
+        throw new Error(`GraphQL error: ${result.errors[0]?.message ?? 'Unknown error'}`);
+    }
+    return result.data?.listApiKeys?.apiKeys ?? [];
+}
+/**
+ * Create a new API key
+ */
+async function createApiKey(apiUrl, accessToken, projectId, tenantId, name) {
+    const response = await fetch(getInternalGraphQLEndpoint(apiUrl), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+            'x-tenant-id': tenantId,
+            'x-project-id': projectId,
+        },
+        body: JSON.stringify({
+            query: `
+        mutation CreateApiKey($input: CreateApiKeyInput!) {
+          createApiKey(input: $input) {
+            apiKey {
+              id
+              name
+              isActive
+            }
+            plainKey
+          }
+        }
+      `,
+            variables: {
+                input: {
+                    name,
+                    projectId,
+                    scopes: ['entities:read', 'files:read'],
+                },
+            },
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to create API key: ${response.statusText}`);
+    }
+    const result = (await response.json());
+    if (result.errors && result.errors.length > 0) {
+        throw new Error(`GraphQL error: ${result.errors[0]?.message ?? 'Unknown error'}`);
+    }
+    if (!result.data?.createApiKey) {
+        throw new Error('Failed to create API key: No data returned');
+    }
+    return result.data.createApiKey;
+}
+/**
+ * Rotate an existing API key to get a new plain key
+ */
+async function rotateApiKey(apiUrl, accessToken, projectId, tenantId, keyId) {
+    const response = await fetch(getInternalGraphQLEndpoint(apiUrl), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+            'x-tenant-id': tenantId,
+            'x-project-id': projectId,
+        },
+        body: JSON.stringify({
+            query: `
+        mutation RotateApiKey($id: ID!) {
+          rotateApiKey(id: $id) {
+            apiKey {
+              id
+              name
+              isActive
+            }
+            plainKey
+          }
+        }
+      `,
+            variables: { id: keyId },
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to rotate API key: ${response.statusText}`);
+    }
+    const result = (await response.json());
+    if (result.errors && result.errors.length > 0) {
+        throw new Error(`GraphQL error: ${result.errors[0]?.message ?? 'Unknown error'}`);
+    }
+    if (!result.data?.rotateApiKey) {
+        throw new Error('Failed to rotate API key: No data returned');
+    }
+    return result.data.rotateApiKey;
+}
+/**
+ * Provision an API key for CLI usage
+ * - If CLI key exists and we have it stored, verify it's still active
+ * - If CLI key exists but we don't have it, rotate to get new plain key
+ * - If CLI key doesn't exist, create one
+ */
+async function provisionApiKey(apiUrl, accessToken, projectId, tenantId) {
+    const apiKeys = await fetchApiKeys(apiUrl, accessToken, projectId, tenantId);
+    const existingCliKey = apiKeys.find((k) => k.name === CLI_API_KEY_NAME && k.isActive);
+    if (existingCliKey) {
+        // Key exists - rotate it to get a new plain key
+        // (We can't retrieve the plain key after creation, only on create/rotate)
+        console.log('  Rotating existing CLI API key...');
+        const rotated = await rotateApiKey(apiUrl, accessToken, projectId, tenantId, existingCliKey.id);
+        return {
+            apiKey: rotated.plainKey,
+            apiKeyId: rotated.apiKey.id,
+        };
+    }
+    else {
+        // No CLI key exists - create one
+        console.log('  Creating CLI API key...');
+        const created = await createApiKey(apiUrl, accessToken, projectId, tenantId, CLI_API_KEY_NAME);
+        return {
+            apiKey: created.plainKey,
+            apiKeyId: created.apiKey.id,
+        };
+    }
+}
+/**
+ * Select project command - choose which project to work with
+ */
+export async function selectProject(options) {
+    const credentials = await getCredentials();
+    if (!credentials) {
+        console.log('Not logged in. Run `uniformgen login` first.');
+        process.exit(1);
+    }
+    console.log('Fetching your projects...\n');
+    // Fetch session context - same pattern as admin app
+    const sessionContext = await fetchSessionContext(options.apiUrl, credentials.accessToken);
+    const { availableTenants: tenants, availableProjects: projects } = sessionContext;
+    if (projects.length === 0) {
+        console.log('No projects found. Create one in the platform first.');
+        process.exit(1);
+    }
+    // Create tenant name lookup map
+    const tenantNameMap = new Map(tenants.map((t) => [t.id, t.name]));
+    let selectedProject;
+    // If project ID provided directly, use it
+    if (options.projectId) {
+        const found = projects.find((p) => p.id === options.projectId);
+        if (!found) {
+            console.log(`Project with ID "${options.projectId}" not found.`);
+            console.log('Available projects:');
+            projects.forEach((p) => console.log(`  - ${p.name} (${p.id})`));
+            process.exit(1);
+        }
+        selectedProject = found;
+    }
+    else {
+        // Interactive selection
+        // Group projects by tenant
+        const byTenant = projects.reduce((acc, p) => {
+            const key = tenantNameMap.get(p.tenantId) ?? 'Unknown';
+            if (!acc[key])
+                acc[key] = [];
+            acc[key].push(p);
+            return acc;
+        }, {});
+        const choices = Object.entries(byTenant).flatMap(([tenantName, tenantProjects]) => [
+            new inquirer.Separator(`── ${tenantName} ──`),
+            ...tenantProjects.map((p) => ({
+                name: `  ${p.name}`,
+                value: p.id,
+                short: p.name,
+            })),
+        ]);
+        const { projectId } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'projectId',
+                message: 'Select a project:',
+                choices,
+            },
+        ]);
+        selectedProject = projects.find((p) => p.id === projectId);
+    }
+    // Provision API key for CLI access
+    console.log('\nProvisioning API key for CLI access...');
+    const { apiKey, apiKeyId } = await provisionApiKey(options.apiUrl, credentials.accessToken, selectedProject.id, selectedProject.tenantId);
+    await updateCredentials({
+        selectedProject: {
+            id: selectedProject.id,
+            name: selectedProject.name,
+            tenantId: selectedProject.tenantId,
+            apiKey,
+            apiKeyId,
+        },
+    });
+    console.log(`\n✓ Selected project: ${selectedProject.name}`);
+    console.log('✓ API key provisioned for CLI access');
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Setup command - configure UniformGen preferences
+ */
+export declare function setup(): Promise<void>;
+//# sourceMappingURL=setup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/commands/setup.ts"],"names":[],"mappings":"AA4BA;;GAEG;AACH,wBAAsB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAiC3C"}