@mandujs/core 0.16.0 → 0.18.0

package/src/resource/generators/contract.ts

@@ -0,0 +1,264 @@
+/**
+ * Resource Contract Generator
+ * Generate Zod contract from resource definition
+ */
+
+import type { ResourceDefinition, ResourceField } from "../schema";
+import { getPluralName, getEnabledEndpoints } from "../schema";
+
+/**
+ * Generate contract file for resource
+ *
+ * @returns Contract file content
+ */
+export function generateResourceContract(definition: ResourceDefinition): string {
+  const resourceName = definition.name;
+  const pascalName = toPascalCase(resourceName);
+  const pluralName = getPluralName(definition);
+  const endpoints = getEnabledEndpoints(definition);
+
+  // Generate schema definitions
+  const schemaDefinitions = generateSchemaDefinitions(definition);
+
+  // Generate request schemas
+  const requestSchemas = generateRequestSchemas(definition, endpoints);
+
+  // Generate response schemas
+  const responseSchemas = generateResponseSchemas(definition, pascalName);
+
+  return `// 📜 Mandu Resource Contract - ${resourceName}
+// Auto-generated from resource definition
+// DO NOT EDIT - Regenerated on every \`mandu generate\`
+
+import { z } from "zod";
+import { Mandu } from "@mandujs/core";
+
+// ============================================
+// 🥟 Schema Definitions
+// ============================================
+
+${schemaDefinitions}
+
+// ============================================
+// 📜 Contract Definition
+// ============================================
+
+export default Mandu.contract({
+  description: "${definition.options?.description || `${pascalName} API`}",
+  tags: ${JSON.stringify(definition.options?.tags || [resourceName])},
+
+  request: {
+${requestSchemas}
+  },
+
+  response: {
+${responseSchemas}
+  },
+});
+`;
+}
+
+/**
+ * Generate schema definitions for fields
+ */
+function generateSchemaDefinitions(definition: ResourceDefinition): string {
+  const pascalName = toPascalCase(definition.name);
+  const fields = Object.entries(definition.fields);
+
+  // Generate individual field schemas
+  const fieldSchemas = fields.map(([name, field]) => {
+    const zodSchema = generateZodSchema(name, field);
+    return `  ${name}: ${zodSchema},`;
+  });
+
+  return `/**
+ * ${pascalName} Schema
+ */
+const ${pascalName}Schema = z.object({
+${fieldSchemas.join("\n")}
+});
+
+/**
+ * ${pascalName} Create Schema (exclude id, createdAt, updatedAt)
+ */
+const ${pascalName}CreateSchema = ${pascalName}Schema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+});
+
+/**
+ * ${pascalName} Update Schema (all fields optional except id)
+ */
+const ${pascalName}UpdateSchema = ${pascalName}Schema.partial().required({ id: true });`;
+}
+
+/**
+ * Generate Zod schema for a field
+ */
+function generateZodSchema(fieldName: string, field: ResourceField): string {
+  // Use custom schema if provided
+  if (field.schema) {
+    return "z.unknown() /* Custom schema */";
+  }
+
+  let schema: string;
+
+  switch (field.type) {
+    case "string":
+      schema = "z.string()";
+      break;
+    case "number":
+      schema = "z.number()";
+      break;
+    case "boolean":
+      schema = "z.boolean()";
+      break;
+    case "date":
+      schema = "z.string().datetime()";
+      break;
+    case "uuid":
+      schema = "z.string().uuid()";
+      break;
+    case "email":
+      schema = "z.string().email()";
+      break;
+    case "url":
+      schema = "z.string().url()";
+      break;
+    case "json":
+      schema = "z.record(z.unknown())";
+      break;
+    case "array":
+      const itemType = field.items || "unknown";
+      schema = `z.array(${generateZodTypeFromFieldType(itemType)})`;
+      break;
+    case "object":
+      schema = "z.record(z.unknown())";
+      break;
+    default:
+      schema = "z.unknown()";
+  }
+
+  // Add optional/required
+  if (!field.required) {
+    schema += ".optional()";
+  }
+
+  // Add default
+  if (field.default !== undefined) {
+    const defaultValue = JSON.stringify(field.default);
+    schema += `.default(${defaultValue})`;
+  }
+
+  // Add description
+  if (field.description) {
+    schema += `.describe("${field.description}")`;
+  }
+
+  return schema;
+}
+
+/**
+ * Generate Zod type from FieldType
+ */
+function generateZodTypeFromFieldType(type: string): string {
+  switch (type) {
+    case "string":
+      return "z.string()";
+    case "number":
+      return "z.number()";
+    case "boolean":
+      return "z.boolean()";
+    case "date":
+      return "z.string().datetime()";
+    case "uuid":
+      return "z.string().uuid()";
+    case "email":
+      return "z.string().email()";
+    case "url":
+      return "z.string().url()";
+    default:
+      return "z.unknown()";
+  }
+}
+
+/**
+ * Generate request schemas based on enabled endpoints
+ */
+function generateRequestSchemas(definition: ResourceDefinition, endpoints: string[]): string {
+  const pascalName = toPascalCase(definition.name);
+  const schemas: string[] = [];
+
+  if (endpoints.includes("list")) {
+    const defaultLimit = definition.options?.pagination?.defaultLimit || 10;
+    const maxLimit = definition.options?.pagination?.maxLimit || 100;
+
+    schemas.push(`    GET: {
+      query: z.object({
+        page: z.coerce.number().int().min(1).default(1),
+        limit: z.coerce.number().int().min(1).max(${maxLimit}).default(${defaultLimit}),
+      }),
+    }`);
+  }
+
+  if (endpoints.includes("create")) {
+    schemas.push(`    POST: {
+      body: ${pascalName}CreateSchema,
+    }`);
+  }
+
+  if (endpoints.includes("update")) {
+    schemas.push(`    PUT: {
+      body: ${pascalName}UpdateSchema,
+    }`);
+  }
+
+  if (endpoints.includes("delete")) {
+    schemas.push(`    DELETE: {
+      // No body for DELETE
+    }`);
+  }
+
+  return schemas.join(",\n\n");
+}
+
+/**
+ * Generate response schemas
+ */
+function generateResponseSchemas(definition: ResourceDefinition, pascalName: string): string {
+  return `    200: z.object({
+      data: z.union([${pascalName}Schema, z.array(${pascalName}Schema)]),
+      pagination: z.object({
+        page: z.number(),
+        limit: z.number(),
+        total: z.number(),
+      }).optional(),
+    }),
+    201: z.object({
+      data: ${pascalName}Schema,
+    }),
+    400: z.object({
+      error: z.string(),
+      details: z.array(z.object({
+        type: z.string(),
+        issues: z.array(z.object({
+          path: z.string(),
+          message: z.string(),
+        })),
+      })).optional(),
+    }),
+    404: z.object({
+      error: z.string(),
+    })`;
+}
+
+/**
+ * Convert string to PascalCase
+ */
+function toPascalCase(str: string): string {
+  return str
+    .split(/[-_]/)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+}

package/src/resource/generators/slot.ts

@@ -0,0 +1,193 @@
+/**
+ * Resource Slot Generator
+ * Generate slot templates for resource endpoints
+ */
+
+import type { ResourceDefinition } from "../schema";
+import { getPluralName, getEnabledEndpoints } from "../schema";
+
+/**
+ * Generate slot file for resource
+ * IMPORTANT: This should only be generated ONCE - never overwrite existing slots!
+ *
+ * @returns Slot file content
+ */
+export function generateResourceSlot(definition: ResourceDefinition): string {
+  const resourceName = definition.name;
+  const pascalName = toPascalCase(resourceName);
+  const pluralName = getPluralName(definition);
+  const endpoints = getEnabledEndpoints(definition);
+
+  // Generate endpoint handlers
+  const handlers = generateHandlers(definition, endpoints, pascalName);
+
+  return `// 🥟 Mandu Filling - ${resourceName} Resource
+// Pattern: /api/${pluralName}
+// 이 파일에서 비즈니스 로직을 구현하세요.
+
+import { Mandu } from "@mandujs/core";
+import contract from "../contracts/${resourceName}.contract";
+
+export default Mandu.filling()
+${handlers}
+
+// 💡 Contract 기반 사용법:
+// ctx.input(contract, "GET")  - Contract로 요청 검증 + 정규화
+// ctx.output(contract, 200, data) - Contract로 응답 검증
+// ctx.okContract(contract, data)  - 200 OK (Contract 검증)
+// ctx.createdContract(contract, data) - 201 Created (Contract 검증)
+//
+// 💡 데이터베이스 연동 예시:
+// const { data } = await db.select().from(${pluralName}).where(eq(${pluralName}.id, id));
+// return ctx.output(contract, 200, { data });
+`;
+}
+
+/**
+ * Generate handlers for enabled endpoints
+ */
+function generateHandlers(
+  definition: ResourceDefinition,
+  endpoints: string[],
+  pascalName: string
+): string {
+  const handlers: string[] = [];
+
+  if (endpoints.includes("list")) {
+    handlers.push(generateListHandler(definition, pascalName));
+  }
+
+  if (endpoints.includes("get")) {
+    handlers.push(generateGetHandler(definition, pascalName));
+  }
+
+  if (endpoints.includes("create")) {
+    handlers.push(generateCreateHandler(definition, pascalName));
+  }
+
+  if (endpoints.includes("update")) {
+    handlers.push(generateUpdateHandler(definition, pascalName));
+  }
+
+  if (endpoints.includes("delete")) {
+    handlers.push(generateDeleteHandler(definition, pascalName));
+  }
+
+  return handlers.join("\n\n");
+}
+
+/**
+ * Generate LIST handler (GET /api/resources)
+ */
+function generateListHandler(definition: ResourceDefinition, pascalName: string): string {
+  return `  // 📋 List ${pascalName}s
+  .get(async (ctx) => {
+    const input = await ctx.input(contract, "GET", ctx.params);
+    const { page, limit } = input;
+
+    // TODO: Implement database query
+    // const offset = (page - 1) * limit;
+    // const items = await db.select().from(${definition.name}s).limit(limit).offset(offset);
+    // const total = await db.select({ count: count() }).from(${definition.name}s);
+
+    const mockData = {
+      data: [], // Replace with actual data
+      pagination: {
+        page,
+        limit,
+        total: 0,
+      },
+    };
+
+    return ctx.output(contract, 200, mockData);
+  })`;
+}
+
+/**
+ * Generate GET handler (GET /api/resources/:id)
+ */
+function generateGetHandler(definition: ResourceDefinition, pascalName: string): string {
+  return `  // 📄 Get Single ${pascalName}
+  .get(async (ctx) => {
+    const { id } = ctx.params;
+
+    // TODO: Implement database query
+    // const item = await db.select().from(${definition.name}s).where(eq(${definition.name}s.id, id)).limit(1);
+    // if (!item) return ctx.notFound("${pascalName} not found");
+
+    const mockData = {
+      data: { id, message: "${pascalName} details" }, // Replace with actual data
+    };
+
+    return ctx.output(contract, 200, mockData);
+  })`;
+}
+
+/**
+ * Generate CREATE handler (POST /api/resources)
+ */
+function generateCreateHandler(definition: ResourceDefinition, pascalName: string): string {
+  return `  // ➕ Create ${pascalName}
+  .post(async (ctx) => {
+    const input = await ctx.input(contract, "POST", ctx.params);
+
+    // TODO: Implement database insertion
+    // const [created] = await db.insert(${definition.name}s).values(input).returning();
+
+    const mockData = {
+      data: { id: "new-id", ...input }, // Replace with actual created data
+    };
+
+    return ctx.output(contract, 201, mockData);
+  })`;
+}
+
+/**
+ * Generate UPDATE handler (PUT /api/resources/:id)
+ */
+function generateUpdateHandler(definition: ResourceDefinition, pascalName: string): string {
+  return `  // ✏️ Update ${pascalName}
+  .put(async (ctx) => {
+    const { id } = ctx.params;
+    const input = await ctx.input(contract, "PUT", ctx.params);
+
+    // TODO: Implement database update
+    // const [updated] = await db.update(${definition.name}s)
+    //   .set(input)
+    //   .where(eq(${definition.name}s.id, id))
+    //   .returning();
+    // if (!updated) return ctx.notFound("${pascalName} not found");
+
+    const mockData = {
+      data: { id, ...input }, // Replace with actual updated data
+    };
+
+    return ctx.output(contract, 200, mockData);
+  })`;
+}
+
+/**
+ * Generate DELETE handler (DELETE /api/resources/:id)
+ */
+function generateDeleteHandler(definition: ResourceDefinition, pascalName: string): string {
+  return `  // 🗑️ Delete ${pascalName}
+  .delete(async (ctx) => {
+    const { id } = ctx.params;
+
+    // TODO: Implement database deletion
+    // const deleted = await db.delete(${definition.name}s).where(eq(${definition.name}s.id, id));
+    // if (!deleted) return ctx.notFound("${pascalName} not found");
+
+    return ctx.output(contract, 200, { data: { message: "${pascalName} deleted" } });
+  })`;
+}
+
+/**
+ * Convert string to PascalCase
+ */
+function toPascalCase(str: string): string {
+  return str
+    .split(/[-_]/)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+}

package/src/resource/generators/types.ts

@@ -0,0 +1,83 @@
+/**
+ * Resource TypeScript Types Generator
+ * Generate TypeScript type definitions from resource
+ */
+
+import type { ResourceDefinition } from "../schema";
+
+/**
+ * Generate TypeScript types for resource
+ *
+ * @returns Types file content
+ */
+export function generateResourceTypes(definition: ResourceDefinition): string {
+  const pascalName = toPascalCase(definition.name);
+  const contractPath = `../contracts/${definition.name}.contract`;
+
+  return `// 🎯 Mandu Resource Types - ${definition.name}
+// Auto-generated from resource definition
+// DO NOT EDIT - Regenerated on every \`mandu generate\`
+
+import type { InferContract, InferQuery, InferBody, InferParams, InferResponse } from "@mandujs/core";
+import contract from "${contractPath}";
+
+/**
+ * Full contract type for ${definition.name}
+ */
+export type ${pascalName}Contract = InferContract<typeof contract>;
+
+// ============================================
+// Request Types
+// ============================================
+
+/** GET query parameters */
+export type ${pascalName}GetQuery = InferQuery<typeof contract, "GET">;
+
+/** POST request body */
+export type ${pascalName}PostBody = InferBody<typeof contract, "POST">;
+
+/** PUT request body */
+export type ${pascalName}PutBody = InferBody<typeof contract, "PUT">;
+
+/** PATCH request body */
+export type ${pascalName}PatchBody = InferBody<typeof contract, "PATCH">;
+
+/** DELETE query parameters */
+export type ${pascalName}DeleteQuery = InferQuery<typeof contract, "DELETE">;
+
+/** Path parameters (if any) */
+export type ${pascalName}Params = InferParams<typeof contract, "GET">;
+
+// ============================================
+// Response Types
+// ============================================
+
+/** 200 OK response */
+export type ${pascalName}Response200 = InferResponse<typeof contract, 200>;
+
+/** 201 Created response */
+export type ${pascalName}Response201 = InferResponse<typeof contract, 201>;
+
+/** 204 No Content response */
+export type ${pascalName}Response204 = InferResponse<typeof contract, 204>;
+
+/** 400 Bad Request response */
+export type ${pascalName}Response400 = InferResponse<typeof contract, 400>;
+
+/** 404 Not Found response */
+export type ${pascalName}Response404 = InferResponse<typeof contract, 404>;
+
+// Re-export contract for runtime use
+export { contract };
+`;
+}
+
+/**
+ * Convert string to PascalCase
+ */
+function toPascalCase(str: string): string {
+  return str
+    .split(/[-_]/)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+}

package/src/resource/index.ts

@@ -0,0 +1,42 @@
+/**
+ * Resource-Centric Architecture
+ * Public API exports
+ */
+
+// Schema API
+export {
+  defineResource,
+  validateResourceDefinition,
+  getPluralName,
+  getEnabledEndpoints,
+  isFieldRequired,
+  getFieldDefault,
+  FieldTypes,
+} from "./schema";
+
+export type {
+  ResourceDefinition,
+  ResourceField,
+  ResourceOptions,
+  FieldType,
+} from "./schema";
+
+// Parser API
+export { parseResourceSchema, parseResourceSchemas, validateResourceUniqueness } from "./parser";
+
+export type { ParsedResource } from "./parser";
+
+// Generator API
+export {
+  generateResourceArtifacts,
+  generateResourcesArtifacts,
+  logGeneratorResult,
+} from "./generator";
+
+export type { GeneratorOptions, GeneratorResult } from "./generator";
+
+// Individual Generators (for advanced use)
+export { generateResourceContract } from "./generators/contract";
+export { generateResourceTypes } from "./generators/types";
+export { generateResourceSlot } from "./generators/slot";
+export { generateResourceClient } from "./generators/client";