@tdk-landscape/tdk-cli-core 1.3.52 → 1.3.54

package/cli/src/commands/resource.ts

@@ -1,652 +0,0 @@
-import { existsSync, mkdirSync } from "node:fs";
-import { isAbsolute, relative, resolve } from "node:path";
-import chalk from "chalk";
-import { Command } from "commander";
-import { hasDddLicense } from "../generator/extension-fetch.js";
-import type { CreatableResourceType, FileGenerationTask } from "../types/index.js";
-import { CREATABLE_RESOURCE_TYPES } from "../types/index.js";
-import { assertValid, confirmOrCancel } from "../utils/command-helpers.js";
-import { errorFactories, requireProjectRoot, runCommand } from "../utils/errors.js";
-import { writeFilesWithProgress } from "../utils/file-helpers.js";
-import { showCommandHeader } from "../utils/formatting.js";
-import { assignPort } from "../utils/port-assignment.js";
-import { promptSelect, promptText } from "../utils/prompt.js";
-import { getDefaultFeaturesForResourceType } from "../utils/resource-features.js";
-import { discoverResources } from "../utils/services.js";
-import { createKebabCaseValidator, isPathSafe, validateResourceName } from "../utils/validation.js";
-
-export const BASE_TEMPLATE = {
-  port: 0, // Will be assigned
-  dependencies: [],
-  build: {
-    dockerfile: "Dockerfile",
-    context: ".",
-  },
-  dev: {
-    command: "bun run dev",
-    watch: ["src/**/*"],
-  },
-} as const;
-
-interface TypeSpecificConfig {
-  healthCheck?: string;
-  dev?: {
-    command: string;
-    watch: string[];
-  };
-}
-
-export const TYPE_SPECIFIC: Record<CreatableResourceType, TypeSpecificConfig> = {
-  backend: {
-    healthCheck: "/health",
-  },
-  frontend: {
-    dev: {
-      command: "bun run dev",
-      watch: ["src/**/*", "public/**/*"],
-    },
-  },
-  worker: {
-    dev: {
-      command: "bun run worker",
-      watch: ["src/**/*"],
-    },
-  },
-};
-
-export function createServiceJson(
-  name: string,
-  type: CreatableResourceType,
-  stack: string,
-  port: number,
-  extraFeatures: string[] = [],
-) {
-  const typeSpecific = TYPE_SPECIFIC[type];
-
-  const base = JSON.parse(JSON.stringify(BASE_TEMPLATE));
-  for (const [key, value] of Object.entries(typeSpecific)) {
-    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-      base[key] = { ...base[key], ...value };
-    } else {
-      base[key] = value;
-    }
-  }
-
-  return {
-    ...base,
-    appName: name,
-    appType: type,
-    featuresEnabled: [...getDefaultFeaturesForResourceType(type), ...extraFeatures],
-    name,
-    type,
-    stack,
-    port,
-  };
-}
-
-export function createPackageJson(name: string, type: string) {
-  const isFrontend = type === "frontend";
-
-  return {
-    name: `@project/${name}`,
-    version: "0.0.1",
-    type: "module",
-    scripts: {
-      dev: isFrontend ? "vite" : "bun run --watch src/index.ts",
-      build: isFrontend ? "tsc && vite build" : "tsc",
-      test: "vitest",
-      lint: "biome check .",
-      "lint:fix": "biome check . --write",
-    },
-    dependencies: {
-      ...(isFrontend ? {} : { hono: "^4.0.0" }),
-    },
-    devDependencies: {
-      "@types/bun": "latest",
-      typescript: "^7.0.2",
-      vitest: "^5.0.0",
-      "@biomejs/biome": "^2.5.13",
-
-      ...(isFrontend ? { vite: "^5.0.0" } : {}),
-    },
-  };
-}
-
-export const TSCONFIG_TEMPLATE = {
-  compilerOptions: {
-    target: "ES2022",
-    module: "ESNext",
-    moduleResolution: "bundler",
-    strict: true,
-    esModuleInterop: true,
-    skipLibCheck: true,
-    forceConsistentCasingInFileNames: true,
-    outDir: "./dist",
-    rootDir: "./src",
-    declaration: true,
-    declarationMap: true,
-    sourceMap: true,
-  },
-  include: ["src/**/*"],
-  exclude: ["node_modules", "dist"],
-};
-
-export const DOCKERFILE_TEMPLATE = `FROM oven/bun:1.2
-
-WORKDIR /app
-
-# Copy package files
-COPY package.json bun.lock ./
-
-# Install dependencies
-RUN bun install --frozen-lockfile
-
-# Copy source
-COPY . .
-
-# Build if needed
-RUN bun run build
-
-# Health check
-HEALTHCHECK --interval=10s --timeout=5s --retries=3 \\
-  CMD curl -f http://localhost:3000/health || exit 1
-
-EXPOSE 3000
-
-CMD ["bun", "run", "start"]
-`;
-
-export function getBackendIndexTemplate(name: string) {
-  return `import { Hono } from 'hono';
-
-const app = new Hono();
-
-// Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
-app.get('/health', (c) => {
-  return c.json({ status: 'ok', service: '${name}' });
-});
-
-app.get('/health/live', (c) => {
-  return c.json({ status: 'alive', timestamp: Date.now() });
-});
-
-app.get('/health/ready', async (c) => {
-  const dependencies: Record<string, string> = {};
-  let allReady = true;
-
-  // Add dependency checks here (database, cache, etc.)
-  // Mark allReady = false if any dependency is unhealthy
-
-  const status = allReady ? 'ready' : 'not_ready';
-  return c.json({ status, dependencies }, allReady ? 200 : 503);
-});
-
-app.get('/', (c) => {
-  return c.json({
-    service: '${name}',
-    version: '1.0.0',
-    endpoints: ['/health', '/health/live', '/health/ready']
-  });
-});
-
-const port = process.env.PORT || 3000;
-console.log('\\n🚀 ${name} running on http://localhost:' + port);
-console.log('📊 Health check: http://localhost:' + port + '/health\\n');
-
-export default {
-  port,
-  fetch: app.fetch,
-};
-`;
-}
-
-function getFrontendIndexTemplate(name: string) {
-  return `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>${name}</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
-  </body>
-</html>
-`;
-}
-
-const FRONTEND_MAIN_TEMPLATE = `import React from 'react';
-import ReactDOM from 'react-dom/client';
-import App from './App';
-
-ReactDOM.createRoot(document.getElementById('root')!).render(
-  <React.StrictMode>
-    <App />
-  </React.StrictMode>,
-);
-`;
-
-function getFrontendAppTemplate(name: string) {
-  return `function App() {
-  return (
-    <div style={{ padding: '2rem', fontFamily: 'system-ui' }}>
-      <h1>${name}</h1>
-      <p>Frontend resource created with TDK</p>
-    </div>
-  );
-}
-
-export default App;
-`;
-}
-
-function getShutdownHandlerTemplate(signal: string): string {
-  return `process.on('${signal}', () => {
-  console.log('[Worker] ${signal} received, shutting down gracefully...');
-  process.exit(0);
-});`;
-}
-
-export function getWorkerIndexTemplate(name: string) {
-  return `console.log('🚀 ${name} worker started');
-
-interface Job {
-  id: string;
-  type: string;
-  payload: Record<string, JsonValue>;
-  priority?: number;
-  timestamp?: string;
-}
-
-const CONFIG = {
-  pollIntervalMs: parseInt(process.env.WORKER_POLL_INTERVAL || '5000'),
-  maxRetries: parseInt(process.env.WORKER_MAX_RETRIES || '3'),
-  batchSize: parseInt(process.env.WORKER_BATCH_SIZE || '10'),
-};
-
-async function processJob(job: Job): Promise<void> {
-  console.log('[Worker] Processing job:', job.id, 'type:', job.type);
-
-  // Add job processing logic here using job.payload
-
-  await new Promise(resolve => setTimeout(resolve, 1000));
-  console.log('[Worker] Job completed:', job.id);
-}
-
-async function fetchJobs(): Promise<Job[]> {
-  // Connect to your queue (Redis, RabbitMQ, etc.) and fetch jobs
-  return [];
-}
-
-async function main() {
-  console.log('[Worker] Configuration:', CONFIG);
-
-  while (true) {
-    try {
-      const jobs = await fetchJobs();
-
-      if (jobs.length === 0) {
-        await new Promise(resolve => setTimeout(resolve, CONFIG.pollIntervalMs));
-        continue;
-      }
-
-      console.log('[Worker] Fetched \${jobs.length} jobs');
-
-      for (const job of jobs) {
-        try {
-          await processJob(job);
-        } catch (error: unknown) {
-          console.error('[Worker] Job failed:', error);
-        }
-      }
-    } catch (error: unknown) {
-      console.error('[Worker] Error in main loop:', error);
-      // Wait before retrying to avoid tight error loops
-      await new Promise(resolve => setTimeout(resolve, CONFIG.pollIntervalMs));
-    }
-  }
-}
-
-${getShutdownHandlerTemplate("SIGTERM")}
-
-${getShutdownHandlerTemplate("SIGINT")}
-
-main().catch((err) => {
-  console.error('[Worker] Fatal error:', err);
-  process.exit(1);
-});
-`;
-}
-
-function getTestTemplate(name: string) {
-  return `import { describe, it, expect } from 'vitest';
-
-describe('${name}', () => {
-  it('should pass a basic test', () => {
-    expect(true).toBe(true);
-  });
-});
-`;
-}
-
-export const resourceCommand = new Command("resource")
-  .description("Create a new resource (service) from scratch, or register an existing one")
-  .argument("[name]", "Resource name (kebab-case)")
-  .option("-t, --type <type>", "Resource type: backend, frontend, worker, sdk", "backend")
-  .option("-s, --stack <stack>", "Stack to assign resource to", "default")
-  .option("-p, --path <path>", "Custom path for resource directory")
-  .option("--resource-path <path>", "Alias for --path (for backward compatibility)")
-  .option("--register-existing", "Register an existing resource without creating templates")
-  .option(
-    "--ddd",
-    "Scaffold DDD (domain-driven design) folders + path aliases (Premium - requires TDK_LICENSE_KEY)",
-  )
-  .action(async (name, options) => {
-    await runCommand(async () => {
-      const projectRoot = requireProjectRoot();
-
-      // Support --resource-path as alias for --path
-      const resourcePath = options.resourcePath || options.path;
-
-      showCommandHeader("Resource Creation");
-
-      const allResources = discoverResources();
-
-      let resourceName = name;
-      if (!resourceName) {
-        const inputName = await promptText({
-          message: "Resource name (kebab-case):",
-          validate: (input: string) => {
-            const validation = createKebabCaseValidator("resource")(input);
-            return validation === true || validation;
-          },
-        });
-        resourceName = inputName;
-      } else {
-        assertValid(validateResourceName(resourceName));
-      }
-
-      // Support sdk type for registering existing SDKs
-      let resourceType: CreatableResourceType | "sdk";
-      const validTypes = [...CREATABLE_RESOURCE_TYPES, "sdk"] as const;
-      if (!validTypes.includes(options.type)) {
-        const selectedType = await promptSelect({
-          message: "Resource type:",
-          choices: [
-            { title: "backend - API service with HTTP endpoints", value: "backend" },
-            { title: "frontend - Web application/UI", value: "frontend" },
-            { title: "worker - Background job processor", value: "worker" },
-            { title: "sdk - Library/SDK (register existing)", value: "sdk" },
-          ],
-        });
-        resourceType = selectedType;
-      } else {
-        resourceType = options.type;
-      }
-
-      let dddEnabled = false;
-      if (options.ddd) {
-        if (resourceType !== "backend" && resourceType !== "worker") {
-          console.log(
-            chalk.yellow(
-              `\n⚠️  --ddd only applies to backend/worker resources, ignoring for type "${resourceType}"`,
-            ),
-          );
-        } else {
-          const granted = await hasDddLicense(projectRoot);
-          if (!granted) {
-            throw new Error(
-              "DDD scaffolding is a Premium feature and requires a license key that grants it. " +
-                "Set export TDK_LICENSE_KEY=<key> (request a Premium license at https://tdk-landscape.github.io/#waitlist) and try again.",
-            );
-          }
-          dddEnabled = true;
-        }
-      }
-
-      let stackName = options.stack;
-      if (stackName === "default") {
-        const existingResources = allResources;
-        const stackSet = new Set<string>();
-        for (const r of existingResources) {
-          if (r.stack) stackSet.add(r.stack);
-        }
-        const existingStacks = Array.from(stackSet);
-
-        if (existingStacks.length > 0) {
-          const selectedStack = await promptSelect({
-            message: "Assign to stack:",
-            choices: [
-              ...existingStacks.map((s) => ({ title: s, value: s })),
-              { title: "Create new stack", value: "__new__" },
-            ],
-          });
-
-          if (selectedStack === "__new__") {
-            const newStack = await promptText({
-              message: "New stack name:",
-              validate: (input: string) => {
-                const validation = createKebabCaseValidator("stack")(input);
-                return validation === true || validation;
-              },
-            });
-            stackName = newStack;
-          } else {
-            stackName = selectedStack;
-          }
-        } else {
-          const newStack = await promptText({
-            message: "Stack name (first resource):",
-            initial: "main",
-            validate: (input: string) => {
-              const validation = createKebabCaseValidator("stack")(input);
-              return validation === true || validation;
-            },
-          });
-          stackName = newStack;
-        }
-      }
-
-      let finalResourcePath = resourcePath;
-      if (!finalResourcePath) {
-        const defaultPaths: Record<CreatableResourceType | "sdk", string> = {
-          backend: `services/${stackName}/${resourceName}`,
-          frontend: `apps/${resourceName}`,
-          worker: `workers/${resourceName}`,
-          sdk: `packages/${resourceName}`,
-        };
-        finalResourcePath = defaultPaths[resourceType];
-      }
-
-      const fullPath = resolve(projectRoot, finalResourcePath);
-
-      // Prevent path traversal attacks
-      const relativePathResult = relative(projectRoot, fullPath);
-      if (relativePathResult.startsWith("..") || isAbsolute(relativePathResult)) {
-        errorFactories.invalidPath(fullPath).exit();
-      }
-
-      if (!isPathSafe(finalResourcePath)) {
-        errorFactories.invalidPath(finalResourcePath).exit();
-      }
-
-      // Check if resource already exists
-      const isExistingResource = existsSync(fullPath);
-      const hasServiceJson = existsSync(resolve(fullPath, "service.json"));
-      const shouldRegisterExisting =
-        options.registerExisting ||
-        resourceType === "sdk" ||
-        (isExistingResource && hasServiceJson);
-
-      if (isExistingResource && !shouldRegisterExisting) {
-        errorFactories.directoryExists(fullPath).exit();
-      }
-
-      const assignedPort =
-        resourceType === "sdk"
-          ? 0
-          : assignPort(resourceType as CreatableResourceType, allResources);
-
-      console.log(chalk.gray("\nResource details:"));
-      console.log(chalk.gray(`  Name:  ${resourceName}`));
-      console.log(chalk.gray(`  Type:  ${resourceType}`));
-      console.log(chalk.gray(`  Stack: ${stackName}`));
-      console.log(chalk.gray(`  Port:  ${assignedPort || "N/A (SDK)"}`));
-      console.log(chalk.gray(`  Path:  ${finalResourcePath}`));
-
-      if (shouldRegisterExisting && hasServiceJson) {
-        console.log(
-          chalk.yellow("\n⚠️  Existing resource detected - will update service.json only"),
-        );
-      }
-
-      const confirmed = await confirmOrCancel(
-        shouldRegisterExisting && hasServiceJson
-          ? "\nRegister existing resource?"
-          : "\nCreate resource?",
-      );
-      if (!confirmed) return;
-
-      // Handle existing resource registration
-      if (shouldRegisterExisting && hasServiceJson) {
-        // Read existing service.json
-        const { readFileSync } = await import("node:fs");
-        const existingServiceJsonPath = resolve(fullPath, "service.json");
-        const existingContent = readFileSync(existingServiceJsonPath, "utf-8");
-        const existingServiceJson = JSON.parse(existingContent);
-
-        // Update with new values while preserving existing fields
-        const updatedServiceJson = {
-          ...existingServiceJson,
-          appName: resourceName,
-          appType: resourceType === "sdk" ? "sdk" : existingServiceJson.appType || resourceType,
-          stack: stackName,
-          ...(assignedPort > 0 && { port: assignedPort }),
-        };
-
-        // Write updated service.json
-        const { writeFileSync } = await import("node:fs");
-        writeFileSync(existingServiceJsonPath, JSON.stringify(updatedServiceJson, null, 2));
-
-        console.log(chalk.green("\n✅ Existing resource registered successfully!"));
-        console.log(chalk.gray(`\nLocation: ${fullPath}`));
-        console.log(chalk.gray(`\nNext steps:`));
-        console.log(chalk.gray(`  tdk up ${stackName}`));
-        return;
-      }
-
-      // Create directory structure for new resources
-      console.log(chalk.blue("\n📁 Creating directory structure..."));
-      mkdirSync(fullPath, { recursive: true });
-      mkdirSync(resolve(fullPath, "src"), { recursive: true });
-      mkdirSync(resolve(fullPath, "tests"), { recursive: true });
-      if (dddEnabled) {
-        for (const layer of ["domain", "application", "infrastructure", "presentation"]) {
-          mkdirSync(resolve(fullPath, "src", layer), { recursive: true });
-        }
-      }
-
-      // Prepare file generation tasks
-      const serviceJson = createServiceJson(
-        resourceName,
-        resourceType as CreatableResourceType,
-        stackName,
-        assignedPort,
-        dddEnabled ? ["ddd"] : [],
-      );
-      const packageJson = createPackageJson(resourceName, resourceType);
-
-      const tasks: FileGenerationTask[] = [
-        {
-          type: "json",
-          filename: "service.json",
-          content: serviceJson,
-          description: "Generating service.json",
-          emoji: "📝",
-        },
-        {
-          type: "json",
-          filename: "package.json",
-          content: packageJson,
-          description: "Generating package.json",
-          emoji: "📦",
-        },
-        {
-          type: "json",
-          filename: "tsconfig.json",
-          content: TSCONFIG_TEMPLATE,
-          description: "Generating tsconfig.json",
-          emoji: "⚙️",
-        },
-        {
-          type: "text",
-          filename: "Dockerfile",
-          content: DOCKERFILE_TEMPLATE,
-          description: "Generating Dockerfile",
-          emoji: "🐳",
-        },
-      ];
-
-      // Add source files based on resource type
-      if (resourceType === "backend") {
-        tasks.push({
-          type: "text",
-          filename: "src/index.ts",
-          content: getBackendIndexTemplate(resourceName),
-          description: "Generating backend source",
-          emoji: "💻",
-        });
-      } else if (resourceType === "frontend") {
-        tasks.push({
-          type: "text",
-          filename: "index.html",
-          content: getFrontendIndexTemplate(resourceName),
-          description: "Generating HTML template",
-          emoji: "💻",
-        });
-        tasks.push({
-          type: "text",
-          filename: "src/main.tsx",
-          content: FRONTEND_MAIN_TEMPLATE,
-          description: "Generating React entry",
-          emoji: "💻",
-        });
-        tasks.push({
-          type: "text",
-          filename: "src/App.tsx",
-          content: getFrontendAppTemplate(resourceName),
-          description: "Generating React app",
-          emoji: "💻",
-        });
-      } else if (resourceType === "worker") {
-        tasks.push({
-          type: "text",
-          filename: "src/index.ts",
-          content: getWorkerIndexTemplate(resourceName),
-          description: "Generating worker source",
-          emoji: "💻",
-        });
-      }
-
-      // Add test file
-      tasks.push({
-        type: "text",
-        filename: `tests/${resourceName}.test.ts`,
-        content: getTestTemplate(resourceName),
-        description: "Generating test file",
-        emoji: "🧪",
-      });
-
-      // Execute all file writes with progress
-      console.log(chalk.blue("💻 Generating source files..."));
-      writeFilesWithProgress(fullPath, tasks);
-
-      console.log(chalk.green("\n✅ Resource created successfully!"));
-      console.log(chalk.gray(`\nLocation: ${fullPath}`));
-      console.log(chalk.gray(`\nNext steps:`));
-      console.log(chalk.gray(`  cd ${finalResourcePath}`));
-      console.log(chalk.gray(`  bun install`));
-      console.log(chalk.gray(`  tdk up ${stackName}`));
-    });
-  });