@mandujs/core 0.17.0 → 0.18.1

package/src/resource/__tests__/schema.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Resource Schema Tests
+ */
+
+import { describe, test, expect } from "bun:test";
+import {
+  defineResource,
+  validateResourceDefinition,
+  getPluralName,
+  getEnabledEndpoints,
+  isFieldRequired,
+  getFieldDefault,
+} from "../schema";
+import {
+  userResourceFixture,
+  postResourceFixture,
+  productResourceFixture,
+  minimalResourceFixture,
+  invalidResourceFixtures,
+} from "./fixtures";
+
+describe("defineResource", () => {
+  test("should accept valid resource definition", () => {
+    const result = defineResource(userResourceFixture);
+
+    expect(result.name).toBe("user");
+    expect(result.fields).toBeDefined();
+    expect(result.options).toBeDefined();
+  });
+
+  test("should apply default options", () => {
+    const result = defineResource(minimalResourceFixture);
+
+    expect(result.options?.autoPlural).toBe(true);
+    expect(result.options?.endpoints).toBeDefined();
+    expect(result.options?.endpoints?.list).toBe(true);
+    expect(result.options?.endpoints?.get).toBe(true);
+    expect(result.options?.endpoints?.create).toBe(true);
+    expect(result.options?.endpoints?.update).toBe(true);
+    expect(result.options?.endpoints?.delete).toBe(true);
+  });
+
+  test("should merge custom options with defaults", () => {
+    const result = defineResource(productResourceFixture);
+
+    expect(result.options?.endpoints?.list).toBe(true);
+    expect(result.options?.endpoints?.update).toBe(false);
+    expect(result.options?.endpoints?.delete).toBe(false);
+  });
+
+  test("should apply default pagination settings", () => {
+    const result = defineResource(minimalResourceFixture);
+
+    expect(result.options?.pagination?.defaultLimit).toBe(10);
+    expect(result.options?.pagination?.maxLimit).toBe(100);
+  });
+
+  test("should preserve custom pagination settings", () => {
+    const result = defineResource(userResourceFixture);
+
+    expect(result.options?.pagination?.defaultLimit).toBe(20);
+    expect(result.options?.pagination?.maxLimit).toBe(100);
+  });
+});
+
+describe("validateResourceDefinition", () => {
+  test("should validate correct resource definition", () => {
+    expect(() => {
+      validateResourceDefinition(userResourceFixture);
+    }).not.toThrow();
+  });
+
+  test("should throw on missing name", () => {
+    expect(() => {
+      validateResourceDefinition(invalidResourceFixtures.noName);
+    }).toThrow("Resource name is required");
+  });
+
+  test("should throw on invalid name format", () => {
+    expect(() => {
+      validateResourceDefinition(invalidResourceFixtures.invalidName);
+    }).toThrow(/Invalid resource name/);
+  });
+
+  test("should throw on empty fields", () => {
+    expect(() => {
+      validateResourceDefinition(invalidResourceFixtures.noFields);
+    }).toThrow(/must have at least one field/);
+  });
+
+  test("should throw on invalid field name", () => {
+    expect(() => {
+      validateResourceDefinition(invalidResourceFixtures.invalidFieldName);
+    }).toThrow(/Invalid field name/);
+  });
+
+  test("should throw on invalid field type", () => {
+    expect(() => {
+      validateResourceDefinition(invalidResourceFixtures.invalidFieldType);
+    }).toThrow(/Invalid field type/);
+  });
+
+  test("should throw on array without items", () => {
+    expect(() => {
+      validateResourceDefinition(invalidResourceFixtures.arrayWithoutItems);
+    }).toThrow(/missing "items" property/);
+  });
+});
+
+describe("getPluralName", () => {
+  test("should add 's' for simple pluralization", () => {
+    const result = getPluralName(userResourceFixture);
+    expect(result).toBe("users");
+  });
+
+  test("should use custom plural name if provided", () => {
+    const result = getPluralName(productResourceFixture);
+    expect(result).toBe("inventory");
+  });
+
+  test("should respect autoPlural: false", () => {
+    const definition = {
+      ...minimalResourceFixture,
+      options: { autoPlural: false },
+    };
+    const result = getPluralName(definition);
+    expect(result).toBe("item");
+  });
+});
+
+describe("getEnabledEndpoints", () => {
+  test("should return all enabled endpoints", () => {
+    const result = getEnabledEndpoints(userResourceFixture);
+    expect(result).toEqual(["list", "get", "create", "update", "delete"]);
+  });
+
+  test("should return only enabled endpoints", () => {
+    const result = getEnabledEndpoints(productResourceFixture);
+    expect(result).toEqual(["list", "get", "create"]);
+    expect(result).not.toContain("update");
+    expect(result).not.toContain("delete");
+  });
+
+  test("should return all endpoints by default", () => {
+    const result = getEnabledEndpoints(minimalResourceFixture);
+    expect(result).toEqual(["list", "get", "create", "update", "delete"]);
+  });
+});
+
+describe("isFieldRequired", () => {
+  test("should return true for required fields", () => {
+    const field = userResourceFixture.fields.email;
+    expect(isFieldRequired(field)).toBe(true);
+  });
+
+  test("should return false for optional fields", () => {
+    const field = userResourceFixture.fields.age;
+    expect(isFieldRequired(field)).toBe(false);
+  });
+
+  test("should return false by default", () => {
+    const field = { type: "string" as const };
+    expect(isFieldRequired(field)).toBe(false);
+  });
+});
+
+describe("getFieldDefault", () => {
+  test("should return default value if provided", () => {
+    const field = userResourceFixture.fields.isActive;
+    expect(getFieldDefault(field)).toBe(true);
+  });
+
+  test("should return undefined if no default", () => {
+    const field = userResourceFixture.fields.email;
+    expect(getFieldDefault(field)).toBeUndefined();
+  });
+
+  test("should handle array default", () => {
+    const field = postResourceFixture.fields.tags;
+    const defaultValue = getFieldDefault(field);
+    expect(Array.isArray(defaultValue)).toBe(true);
+    expect(defaultValue).toEqual([]);
+  });
+});

package/src/resource/generator.ts

@@ -0,0 +1,277 @@
+/**
+ * Resource Generator
+ * Main orchestrator for generating resource artifacts
+ */
+
+import type { ParsedResource } from "./parser";
+import { generateResourceContract } from "./generators/contract";
+import { generateResourceTypes } from "./generators/types";
+import { generateResourceSlot } from "./generators/slot";
+import { generateResourceClient } from "./generators/client";
+import { resolveGeneratedPaths } from "../paths";
+import path from "path";
+import fs from "fs/promises";
+
+// ============================================
+// Generator Options
+// ============================================
+
+export interface GeneratorOptions {
+  /** 프로젝트 루트 디렉토리 */
+  rootDir: string;
+  /** 기존 슬롯 덮어쓰기 (기본: false) */
+  force?: boolean;
+  /** 특정 파일만 생성 */
+  only?: ("contract" | "types" | "slot" | "client")[];
+}
+
+// ============================================
+// Generator Result
+// ============================================
+
+export interface GeneratorResult {
+  success: boolean;
+  created: string[];
+  skipped: string[];
+  errors: string[];
+}
+
+// ============================================
+// File Utilities
+// ============================================
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureDir(dirPath: string): Promise<void> {
+  try {
+    await fs.mkdir(dirPath, { recursive: true });
+  } catch (error) {
+    // Ignore if exists
+  }
+}
+
+// ============================================
+// Generate Resource Artifacts
+// ============================================
+
+/**
+ * Generate all artifacts for a resource
+ *
+ * @param parsed - Parsed resource schema
+ * @param options - Generator options
+ * @returns Generation result
+ *
+ * @example
+ * ```typescript
+ * const parsed = await parseResourceSchema("/path/to/user.resource.ts");
+ * const result = await generateResourceArtifacts(parsed, {
+ *   rootDir: process.cwd(),
+ *   force: false,
+ * });
+ * ```
+ */
+export async function generateResourceArtifacts(
+  parsed: ParsedResource,
+  options: GeneratorOptions
+): Promise<GeneratorResult> {
+  const result: GeneratorResult = {
+    success: true,
+    created: [],
+    skipped: [],
+    errors: [],
+  };
+
+  const { definition, resourceName } = parsed;
+  const { rootDir, force = false, only } = options;
+
+  const paths = resolveGeneratedPaths(rootDir);
+
+  try {
+    // 1. Generate Contract (always regenerate)
+    if (!only || only.includes("contract")) {
+      await generateContract(definition, resourceName, paths.resourceContractsDir, result);
+    }
+
+    // 2. Generate Types (always regenerate)
+    if (!only || only.includes("types")) {
+      await generateTypes(definition, resourceName, paths.resourceTypesDir, result);
+    }
+
+    // 3. Generate Slot (PRESERVE if exists unless --force)
+    if (!only || only.includes("slot")) {
+      await generateSlot(definition, resourceName, paths.resourceSlotsDir, force, result);
+    }
+
+    // 4. Generate Client (always regenerate)
+    if (!only || only.includes("client")) {
+      await generateClient(definition, resourceName, paths.resourceClientDir, result);
+    }
+  } catch (error) {
+    result.success = false;
+    result.errors.push(
+      `Failed to generate resource "${resourceName}": ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+
+  return result;
+}
+
+/**
+ * Generate contract file
+ */
+async function generateContract(
+  definition: any,
+  resourceName: string,
+  contractsDir: string,
+  result: GeneratorResult
+): Promise<void> {
+  await ensureDir(contractsDir);
+
+  const contractPath = path.join(contractsDir, `${resourceName}.contract.ts`);
+  const contractContent = generateResourceContract(definition);
+
+  await Bun.write(contractPath, contractContent);
+  result.created.push(contractPath);
+}
+
+/**
+ * Generate types file
+ */
+async function generateTypes(
+  definition: any,
+  resourceName: string,
+  typesDir: string,
+  result: GeneratorResult
+): Promise<void> {
+  await ensureDir(typesDir);
+
+  const typesPath = path.join(typesDir, `${resourceName}.types.ts`);
+  const typesContent = generateResourceTypes(definition);
+
+  await Bun.write(typesPath, typesContent);
+  result.created.push(typesPath);
+}
+
+/**
+ * Generate slot file (PRESERVE if exists!)
+ */
+async function generateSlot(
+  definition: any,
+  resourceName: string,
+  slotsDir: string,
+  force: boolean,
+  result: GeneratorResult
+): Promise<void> {
+  await ensureDir(slotsDir);
+
+  const slotPath = path.join(slotsDir, `${resourceName}.slot.ts`);
+  const slotExists = await fileExists(slotPath);
+
+  // CRITICAL: Slot preservation logic
+  if (!slotExists || force) {
+    const slotContent = generateResourceSlot(definition);
+    await Bun.write(slotPath, slotContent);
+    result.created.push(slotPath);
+
+    if (slotExists && force) {
+      console.log(`⚠️  Overwriting existing slot (--force): ${slotPath}`);
+    }
+  } else {
+    result.skipped.push(slotPath);
+    console.log(`✓ Preserving existing slot: ${slotPath}`);
+  }
+}
+
+/**
+ * Generate client file
+ */
+async function generateClient(
+  definition: any,
+  resourceName: string,
+  clientDir: string,
+  result: GeneratorResult
+): Promise<void> {
+  await ensureDir(clientDir);
+
+  const clientPath = path.join(clientDir, `${resourceName}.client.ts`);
+  const clientContent = generateResourceClient(definition);
+
+  await Bun.write(clientPath, clientContent);
+  result.created.push(clientPath);
+}
+
+// ============================================
+// Batch Generation
+// ============================================
+
+/**
+ * Generate artifacts for multiple resources
+ *
+ * @param resources - Array of parsed resources
+ * @param options - Generator options
+ * @returns Combined generation result
+ */
+export async function generateResourcesArtifacts(
+  resources: ParsedResource[],
+  options: GeneratorOptions
+): Promise<GeneratorResult> {
+  const combinedResult: GeneratorResult = {
+    success: true,
+    created: [],
+    skipped: [],
+    errors: [],
+  };
+
+  for (const resource of resources) {
+    const result = await generateResourceArtifacts(resource, options);
+
+    combinedResult.created.push(...result.created);
+    combinedResult.skipped.push(...result.skipped);
+    combinedResult.errors.push(...result.errors);
+
+    if (!result.success) {
+      combinedResult.success = false;
+    }
+  }
+
+  return combinedResult;
+}
+
+// ============================================
+// Summary Logging
+// ============================================
+
+/**
+ * Log generation result summary
+ */
+export function logGeneratorResult(result: GeneratorResult): void {
+  console.log("\n📦 Resource Generation Summary:");
+  console.log(`  ✅ Created: ${result.created.length} files`);
+  console.log(`  ⏭️  Skipped: ${result.skipped.length} files`);
+
+  if (result.errors.length > 0) {
+    console.log(`  ❌ Errors: ${result.errors.length}`);
+    result.errors.forEach((error) => console.error(`    - ${error}`));
+  }
+
+  if (result.created.length > 0) {
+    console.log("\n  Created files:");
+    result.created.forEach((file) => console.log(`    - ${file}`));
+  }
+
+  if (result.skipped.length > 0) {
+    console.log("\n  Skipped (preserved):");
+    result.skipped.forEach((file) => console.log(`    - ${file}`));
+  }
+
+  console.log();
+}

package/src/resource/generators/client.ts

@@ -0,0 +1,199 @@
+/**
+ * Resource Client Generator
+ * Generate type-safe client methods for resource API
+ */
+
+import type { ResourceDefinition } from "../schema";
+import { getPluralName, getEnabledEndpoints } from "../schema";
+
+/**
+ * Generate client file for resource
+ *
+ * @returns Client file content
+ */
+export function generateResourceClient(definition: ResourceDefinition): string {
+  const resourceName = definition.name;
+  const pascalName = toPascalCase(resourceName);
+  const pluralName = getPluralName(definition);
+  const endpoints = getEnabledEndpoints(definition);
+
+  // Generate client methods
+  const methods = generateClientMethods(definition, endpoints, pascalName, pluralName);
+
+  return `// 🌐 Mandu Client - ${resourceName} Resource
+// Auto-generated from resource definition
+// DO NOT EDIT - Regenerated on every \`mandu generate\`
+
+import type {
+  ${pascalName}GetQuery,
+  ${pascalName}PostBody,
+  ${pascalName}PutBody,
+  ${pascalName}Response200,
+  ${pascalName}Response201,
+} from "../types/${resourceName}.types";
+
+/**
+ * ${pascalName} Resource Client
+ * Type-safe API client for ${pluralName}
+ */
+export class ${pascalName}Client {
+  private baseUrl: string;
+
+  constructor(baseUrl: string = "") {
+    this.baseUrl = baseUrl;
+  }
+
+${methods}
+
+  /**
+   * Internal fetch wrapper with error handling
+   */
+  private async fetch<T>(
+    path: string,
+    options?: RequestInit
+  ): Promise<T> {
+    const url = \`\${this.baseUrl}\${path}\`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(error.error || \`HTTP \${response.status}\`);
+    }
+
+    return response.json();
+  }
+}
+
+/**
+ * Create a ${pascalName} client instance
+ */
+export function create${pascalName}Client(baseUrl?: string): ${pascalName}Client {
+  return new ${pascalName}Client(baseUrl);
+}
+`;
+}
+
+/**
+ * Generate client methods for enabled endpoints
+ */
+function generateClientMethods(
+  definition: ResourceDefinition,
+  endpoints: string[],
+  pascalName: string,
+  pluralName: string
+): string {
+  const methods: string[] = [];
+
+  if (endpoints.includes("list")) {
+    methods.push(generateListMethod(pascalName, pluralName));
+  }
+
+  if (endpoints.includes("get")) {
+    methods.push(generateGetMethod(pascalName, pluralName));
+  }
+
+  if (endpoints.includes("create")) {
+    methods.push(generateCreateMethod(pascalName, pluralName));
+  }
+
+  if (endpoints.includes("update")) {
+    methods.push(generateUpdateMethod(pascalName, pluralName));
+  }
+
+  if (endpoints.includes("delete")) {
+    methods.push(generateDeleteMethod(pascalName, pluralName));
+  }
+
+  return methods.join("\n\n");
+}
+
+/**
+ * Generate LIST method
+ */
+function generateListMethod(pascalName: string, pluralName: string): string {
+  return `  /**
+   * List ${pascalName}s with pagination
+   */
+  async list(query?: ${pascalName}GetQuery): Promise<${pascalName}Response200> {
+    const params = new URLSearchParams();
+    if (query?.page) params.set("page", String(query.page));
+    if (query?.limit) params.set("limit", String(query.limit));
+
+    const queryString = params.toString();
+    const path = queryString ? \`/api/${pluralName}?\${queryString}\` : \`/api/${pluralName}\`;
+
+    return this.fetch<${pascalName}Response200>(path);
+  }`;
+}
+
+/**
+ * Generate GET method
+ */
+function generateGetMethod(pascalName: string, pluralName: string): string {
+  return `  /**
+   * Get a single ${pascalName} by ID
+   */
+  async get(id: string): Promise<${pascalName}Response200> {
+    return this.fetch<${pascalName}Response200>(\`/api/${pluralName}/\${id}\`);
+  }`;
+}
+
+/**
+ * Generate CREATE method
+ */
+function generateCreateMethod(pascalName: string, pluralName: string): string {
+  return `  /**
+   * Create a new ${pascalName}
+   */
+  async create(data: ${pascalName}PostBody): Promise<${pascalName}Response201> {
+    return this.fetch<${pascalName}Response201>(\`/api/${pluralName}\`, {
+      method: "POST",
+      body: JSON.stringify(data),
+    });
+  }`;
+}
+
+/**
+ * Generate UPDATE method
+ */
+function generateUpdateMethod(pascalName: string, pluralName: string): string {
+  return `  /**
+   * Update an existing ${pascalName}
+   */
+  async update(id: string, data: ${pascalName}PutBody): Promise<${pascalName}Response200> {
+    return this.fetch<${pascalName}Response200>(\`/api/${pluralName}/\${id}\`, {
+      method: "PUT",
+      body: JSON.stringify(data),
+    });
+  }`;
+}
+
+/**
+ * Generate DELETE method
+ */
+function generateDeleteMethod(pascalName: string, pluralName: string): string {
+  return `  /**
+   * Delete a ${pascalName}
+   */
+  async delete(id: string): Promise<${pascalName}Response200> {
+    return this.fetch<${pascalName}Response200>(\`/api/${pluralName}/\${id}\`, {
+      method: "DELETE",
+    });
+  }`;
+}
+
+/**
+ * Convert string to PascalCase
+ */
+function toPascalCase(str: string): string {
+  return str
+    .split(/[-_]/)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+}