@kithinji/pod 1.0.0

package/src/plugins/generators/generate_controller.ts

@@ -0,0 +1,308 @@
+import * as path from "path";
+import { parseSync } from "@swc/core";
+import type {
+  ClassDeclaration,
+  Decorator,
+  Param,
+  ImportDeclaration,
+} from "@swc/core";
+
+interface ServiceMethod {
+  name: string;
+  params: MethodParam[];
+  returnType: string;
+  isAsync: boolean;
+  paramSchemas: string[];
+  returnSchema?: string;
+}
+
+interface MethodParam {
+  name: string;
+  type: string;
+  decorators: string[];
+}
+
+interface ServiceInfo {
+  className: string;
+  methods: ServiceMethod[];
+  hasInjectable: boolean;
+  importMap: Record<string, string>;
+}
+
+export function generateController(
+  filePath: string,
+  code: string
+): string | null {
+  const ast = parseSync(code, {
+    syntax: "typescript",
+    tsx: filePath.endsWith("x"),
+    decorators: true,
+  });
+
+  const serviceInfo = extractServiceInfo(ast);
+  if (!serviceInfo || !serviceInfo.hasInjectable) return null;
+
+  return generateControllerCode(serviceInfo, filePath);
+}
+
+function extractServiceInfo(ast: any): ServiceInfo | null {
+  let serviceClass: ClassDeclaration | null = null;
+  let hasInjectable = false;
+  const importMap: Record<string, string> = {};
+
+  for (const item of ast.body) {
+    if (item.type === "ImportDeclaration") {
+      const decl = item as ImportDeclaration;
+      const source = decl.source.value;
+      decl.specifiers.forEach((spec) => {
+        if (
+          spec.type === "ImportSpecifier" ||
+          spec.type === "ImportDefaultSpecifier" ||
+          spec.type === "ImportNamespaceSpecifier"
+        ) {
+          importMap[spec.local.value] = source;
+        }
+      });
+    }
+
+    if (
+      item.type === "ExportDeclaration" &&
+      item.declaration.type === "ClassDeclaration"
+    ) {
+      const classDecl = item.declaration as ClassDeclaration;
+      if (hasInjectableDecorator(classDecl.decorators)) {
+        serviceClass = classDecl;
+        hasInjectable = true;
+      }
+    }
+  }
+
+  if (!serviceClass || !serviceClass.identifier) return null;
+
+  return {
+    className: serviceClass.identifier.value,
+    methods: extractMethods(serviceClass),
+    hasInjectable,
+    importMap,
+  };
+}
+
+function hasInjectableDecorator(decorators?: Decorator[]): boolean {
+  return (
+    decorators?.some((d) => {
+      const expr = d.expression;
+      return (
+        (expr.type === "Identifier" && expr.value === "Injectable") ||
+        (expr.type === "CallExpression" &&
+          expr.callee.type === "Identifier" &&
+          expr.callee.value === "Injectable")
+      );
+    }) ?? false
+  );
+}
+
+function extractMethods(classDecl: ClassDeclaration): ServiceMethod[] {
+  const methods: ServiceMethod[] = [];
+
+  for (const member of classDecl.body) {
+    if (member.type === "ClassMethod" && member.accessibility === "public") {
+      const method = member as any;
+      const methodName =
+        method.key.type === "Identifier" ? method.key.value : "";
+      if (!methodName) continue;
+
+      if (!method.function.async) {
+        throw new Error(
+          `Server action ${classDecl.identifier.value}.${methodName} must be async.`
+        );
+      }
+
+      const { paramSchemas, returnSchema } = extractSignature(
+        method.function.decorators,
+        method.function.params.length
+      );
+
+      methods.push({
+        name: methodName,
+        params: extractMethodParams(method.function.params),
+        returnType: extractReturnType(method.function.returnType),
+        isAsync: true,
+        paramSchemas,
+        returnSchema,
+      });
+    }
+  }
+  return methods;
+}
+
+function extractSignature(
+  decorators: Decorator[] | undefined,
+  paramCount: number
+) {
+  if (!decorators) return { paramSchemas: [] };
+
+  for (const decorator of decorators) {
+    const expr = decorator.expression;
+    if (
+      expr.type === "CallExpression" &&
+      expr.callee.type === "Identifier" &&
+      expr.callee.value === "Signature"
+    ) {
+      const args = expr.arguments;
+      if (args.length === 0) return { paramSchemas: [] };
+
+      const schemaStrings = args.map((arg) =>
+        stringifyExpression(arg.expression)
+      );
+
+      if (args.length === 1) {
+        return { paramSchemas: [], returnSchema: schemaStrings[0] };
+      }
+
+      return {
+        paramSchemas: schemaStrings.slice(0, -1),
+        returnSchema: schemaStrings[schemaStrings.length - 1],
+      };
+    }
+  }
+  return { paramSchemas: [] };
+}
+
+function stringifyExpression(expr: any): string {
+  if (expr.type === "Identifier") return expr.value;
+  if (expr.type === "MemberExpression") {
+    return `${stringifyExpression(expr.object)}.${expr.property.value || ""}`;
+  }
+  if (expr.type === "CallExpression") {
+    const args = expr.arguments
+      .map((a: any) => stringifyExpression(a.expression))
+      .join(", ");
+    return `${stringifyExpression(expr.callee)}(${args})`;
+  }
+  return "any";
+}
+
+function extractMethodParams(params: Param[]): MethodParam[] {
+  return params.map((p) => {
+    const pat = (p as any).pat;
+    return {
+      name: pat.value,
+      type: pat.typeAnnotation
+        ? stringifyType(pat.typeAnnotation.typeAnnotation)
+        : "any",
+      decorators: [],
+    };
+  });
+}
+
+function extractReturnType(node: any): string {
+  if (!node?.typeAnnotation) return "any";
+  const type = node.typeAnnotation;
+  if (type.type === "TsTypeReference" && type.typeName.value === "Promise") {
+    return stringifyType(type.typeParams?.params[0]);
+  }
+  return stringifyType(type);
+}
+
+function stringifyType(node: any): string {
+  if (!node) return "any";
+  switch (node.type) {
+    case "TsKeywordType":
+      return node.kind;
+    case "TsTypeReference":
+      const base = node.typeName.value;
+      const args = node.typeParams
+        ? `<${node.typeParams.params.map(stringifyType).join(", ")}>`
+        : "";
+      return base + args;
+    case "TsArrayType":
+      return `${stringifyType(node.elemType)}[]`;
+    default:
+      return "any";
+  }
+}
+
+function generateControllerCode(
+  serviceInfo: ServiceInfo,
+  filePath: string
+): string {
+  const serviceName = serviceInfo.className;
+  const controllerName = serviceName.replace(/Service$/, "AutoController");
+  const serviceImportPath = `./${path.basename(filePath).replace(/\.ts$/, "")}`;
+
+  const importGroups = new Map<string, Set<string>>();
+
+  const registerIdentifier = (id: string) => {
+    const source = serviceInfo.importMap[id] || serviceImportPath;
+    if (!importGroups.has(source)) importGroups.set(source, new Set());
+    importGroups.get(source)!.add(id);
+  };
+
+  serviceInfo.methods.forEach((m) => {
+    [...m.paramSchemas, m.returnSchema].filter(Boolean).forEach((s) => {
+      const matches = s!.match(/[A-Z][a-zA-Z0-9]*/g); 
+      matches?.forEach(registerIdentifier);
+      if (s!.includes("z.")) registerIdentifier("z"); 
+    });
+  });
+
+  let importStrings = `import { Controller, Post, Get, Body } from "@kithinji/orca";\n`;
+
+  importGroups.forEach((ids, source) => {
+    const filteredIds = Array.from(ids).filter((id) => id !== serviceName);
+    if (filteredIds.length > 0) {
+      importStrings += `\nimport { ${filteredIds.join(
+        ", "
+      )} } from "${source}";`;
+    }
+  });
+
+  const methods = serviceInfo.methods
+    .map((m) => {
+      const hasParams = m.params.length > 0;
+      const bodyParam = hasParams ? `@Body() body: any` : "";
+
+      let body = "";
+      if (hasParams) {
+        if (m.paramSchemas.length > 0) {
+          body += `    const b = typeof body === 'object' && body !== null ? body : {};\n`;
+          m.params.forEach((p, i) => {
+            body += `    const ${p.name} = ${m.paramSchemas[i]}.parse(b.${p.name});\n`;
+          });
+        } else {
+          body += `    const { ${m.params
+            .map((p) => p.name)
+            .join(", ")} } = body;\n`;
+        }
+      }
+
+      const callArgs = m.params.map((p) => p.name).join(", ");
+      const serviceCall = `this.${
+        serviceName.charAt(0).toLowerCase() + serviceName.slice(1)
+      }.${m.name}(${callArgs})`;
+
+      if (m.returnSchema) {
+        body += `    const res = await ${serviceCall};\n    return ${m.returnSchema}.parse(res);`;
+      } else {
+        body += `    return ${serviceCall};`;
+      }
+
+      return `  @${hasParams ? "Post" : "Get"}("${m.name}")\n  async ${
+        m.name
+      }(${bodyParam}): Promise<${m.returnType}> {\n${body}\n  }`;
+    })
+    .join("\n\n");
+
+  return `${importStrings}
+
+@Controller("/${serviceName}", {
+  providedIn: "root",
+})
+export class ${controllerName} {
+  constructor(private readonly ${
+    serviceName.charAt(0).toLowerCase() + serviceName.slice(1)
+  }: ${serviceName}) {}
+
+${methods}
+}`;
+}

package/src/plugins/generators/generate_rsc.ts

@@ -0,0 +1,274 @@
+import { parseSync } from "@swc/core";
+import type { ClassDeclaration, Decorator } from "@swc/core";
+
+interface ServiceMethod {
+  name: string;
+  params: MethodParam[];
+  returnType: string;
+  isAsync: boolean;
+}
+
+interface MethodParam {
+  name: string;
+  type: string;
+}
+
+interface ServiceInfo {
+  className: string;
+  methods: ServiceMethod[];
+}
+
+export function generateRscStub(filePath: string, code: string): string {
+  const ast = parseSync(code, {
+    syntax: "typescript",
+    tsx: filePath.endsWith("x"),
+    decorators: true,
+  });
+
+  const serviceInfo = extractServiceInfo(ast);
+
+  return generateStubCode(serviceInfo);
+}
+
+function extractServiceInfo(ast: any): ServiceInfo {
+  let serviceClass: ClassDeclaration | null = null;
+
+  for (const item of ast.body) {
+    if (
+      item.type === "ExportDeclaration" &&
+      item.declaration.type === "ClassDeclaration"
+    ) {
+      const classDecl = item.declaration as ClassDeclaration;
+
+      if (hasInjectableDecorator(classDecl.decorators)) {
+        serviceClass = classDecl;
+        break;
+      }
+    }
+  }
+
+  if (!serviceClass || !serviceClass.identifier) {
+    throw new Error("Service class is undefined");
+  }
+
+  const className = serviceClass.identifier.value;
+  const methods = extractMethods(serviceClass);
+
+  return {
+    className,
+    methods,
+  };
+}
+
+function hasInjectableDecorator(decorators?: Decorator[]): boolean {
+  if (!decorators) return false;
+
+  return decorators.some((decorator) => {
+    const expr = decorator.expression;
+
+    if (expr.type === "CallExpression") {
+      if (
+        expr.callee.type === "Identifier" &&
+        expr.callee.value === "Injectable"
+      ) {
+        return true;
+      }
+    }
+
+    if (expr.type === "Identifier" && expr.value === "Injectable") {
+      return true;
+    }
+
+    return false;
+  });
+}
+
+function extractMethods(classDecl: ClassDeclaration): ServiceMethod[] {
+  const methods: ServiceMethod[] = [];
+
+  for (const member of classDecl.body) {
+    if (member.type === "ClassMethod" && member.accessibility === "public") {
+      const method = member as any;
+
+      const methodName =
+        method.key.type === "Identifier" ? method.key.value : "";
+
+      if (!methodName) {
+        continue;
+      }
+
+      if (!method.function.async) {
+        throw new Error(
+          `Server action ${classDecl.identifier.value}.${methodName} must be async.`
+        );
+      }
+
+      const params = extractMethodParams(method.function.params || []);
+      const returnType = extractReturnType(method.function.returnType);
+      const isAsync = method.function.async || false;
+
+      methods.push({
+        name: methodName,
+        params,
+        returnType,
+        isAsync,
+      });
+    }
+  }
+
+  return methods;
+}
+
+function extractMethodParams(params: any[]): MethodParam[] {
+  const result: MethodParam[] = [];
+
+  for (const param of params) {
+    if (param.type === "Parameter") {
+      const pat = param.pat as any;
+
+      if (pat.type === "Identifier") {
+        const name = pat.value;
+        const type = pat.typeAnnotation?.typeAnnotation
+          ? stringifyType(pat.typeAnnotation.typeAnnotation)
+          : "any";
+
+        result.push({
+          name,
+          type,
+        });
+      }
+    }
+  }
+
+  return result;
+}
+
+function extractReturnType(returnType?: any): string {
+  if (!returnType || !returnType.typeAnnotation) {
+    return "any";
+  }
+
+  const type = returnType.typeAnnotation;
+
+  if (type.type === "TsTypeReference") {
+    const typeName = type.typeName;
+    if (typeName.type === "Identifier" && typeName.value === "Promise") {
+      if (type.typeParams && type.typeParams.params.length > 0) {
+        return stringifyType(type.typeParams.params[0]);
+      }
+    }
+  }
+
+  return stringifyType(type);
+}
+
+function stringifyType(typeNode: any): string {
+  if (!typeNode) return "any";
+
+  switch (typeNode.type) {
+    case "TsKeywordType":
+      return typeNode.kind;
+
+    case "TsTypeReference":
+      if (typeNode.typeName.type === "Identifier") {
+        const baseName = typeNode.typeName.value;
+        if (typeNode.typeParams && typeNode.typeParams.params.length > 0) {
+          const params = typeNode.typeParams.params
+            .map(stringifyType)
+            .join(", ");
+          return `${baseName}<${params}>`;
+        }
+        return baseName;
+      }
+      return "any";
+
+    case "TsArrayType":
+      return `${stringifyType(typeNode.elemType)}[]`;
+
+    case "TsUnionType":
+      return typeNode.types.map(stringifyType).join(" | ");
+
+    case "TsIntersectionType":
+      return typeNode.types.map(stringifyType).join(" & ");
+
+    case "TsTypeLiteral":
+      const props = typeNode.members
+        .map((member: any) => {
+          if (member.type === "TsPropertySignature") {
+            const key =
+              member.key.type === "Identifier" ? member.key.value : "";
+            const type = member.typeAnnotation
+              ? stringifyType(member.typeAnnotation.typeAnnotation)
+              : "any";
+            return `${key}: ${type}`;
+          }
+          return "";
+        })
+        .filter(Boolean);
+      return `{ ${props.join("; ")} }`;
+
+    default:
+      return "any";
+  }
+}
+
+function generateStubCode(serviceInfo: ServiceInfo): string {
+  const className = serviceInfo.className;
+
+  const methods = serviceInfo.methods
+    .map((method) => {
+      const params = method.params
+        .map((p) => `${p.name}: ${p.type}`)
+        .join(", ");
+      const paramNames = method.params.map((p) => p.name).join(", ");
+
+      const asyncKeyword = method.isAsync ? "async " : "";
+      const returnType = method.isAsync
+        ? `Promise<${method.returnType}>`
+        : method.returnType;
+
+      const hasParams = method.params.length > 0;
+      const bodyParam = hasParams ? `{ ${paramNames} }` : "{}";
+
+      if (!hasParams) {
+        return `  ${asyncKeyword}${method.name}(${params}): ${returnType} {
+    const response = await fetch(\`/${className}/${method.name}\`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      }
+    });
+
+    if (!response.ok) {
+      throw new Error(\`HTTP error! status: \${response.status}\`);
+    }
+
+    return response.json();
+  }`;
+      }
+
+      return `  ${asyncKeyword}${method.name}(${params}): ${returnType} {
+    const response = await fetch(\`/${className}/${method.name}\`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(${bodyParam}),
+    });
+
+    if (!response.ok) {
+      throw new Error(\`HTTP error! status: \${response.status}\`);
+    }
+
+    return response.json();
+  }`;
+    })
+    .join("\n\n");
+
+  return `import { Injectable } from "@kithinji/orca";
+
+@Injectable()
+export class ${className} {
+${methods}
+}`;
+}