@kithinji/pod 1.0.23 → 1.0.24

package/dist/main.js

@@ -928,79 +928,144 @@ async function expandMacros(source, filePath, projectRoot = process.cwd()) {
 import * as path4 from "path";
 import { parseSync } from "@swc/core";
 function generateController(filePath, code) {
-  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);
+  try {
+    const ast = parseSync(code, {
+      syntax: "typescript",
+      tsx: filePath.endsWith("x") || filePath.endsWith(".tsx"),
+      decorators: true
+    });
+    const serviceInfo = extractServiceInfo(ast, filePath);
+    if (!serviceInfo || !serviceInfo.hasInjectable) {
+      return null;
+    }
+    validateServiceInfo(serviceInfo, filePath);
+    return generateControllerCode(serviceInfo, filePath);
+  } catch (error) {
+    if (error.type) {
+      throw error;
+    }
+    throw {
+      type: "parse",
+      message: `Failed to parse TypeScript file: ${error.message}`,
+      filePath,
+      details: error
+    };
+  }
 }
-function extractServiceInfo(ast) {
+function extractServiceInfo(ast, filePath) {
   let serviceClass = null;
   let hasInjectable = false;
   const importMap = {};
-  for (const item of ast.body) {
-    if (item.type === "ImportDeclaration") {
-      const decl = item;
-      const source = decl.source.value;
-      decl.specifiers.forEach((spec) => {
-        if (spec.type === "ImportSpecifier" || spec.type === "ImportDefaultSpecifier" || spec.type === "ImportNamespaceSpecifier") {
-          importMap[spec.local.value] = source;
+  try {
+    for (const item of ast.body) {
+      if (item.type === "ImportDeclaration") {
+        const decl = item;
+        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;
+        if (hasInjectableDecorator(classDecl.decorators)) {
+          serviceClass = classDecl;
+          hasInjectable = true;
         }
-      });
-    }
-    if (item.type === "ExportDeclaration" && item.declaration.type === "ClassDeclaration") {
-      const classDecl = item.declaration;
-      if (hasInjectableDecorator(classDecl.decorators)) {
-        serviceClass = classDecl;
-        hasInjectable = true;
       }
     }
+    if (!serviceClass?.identifier) {
+      return null;
+    }
+    return {
+      className: serviceClass.identifier.value,
+      methods: extractMethods(serviceClass, filePath),
+      hasInjectable,
+      importMap
+    };
+  } catch (error) {
+    throw {
+      type: "parse",
+      message: `Failed to extract service info: ${error.message}`,
+      filePath,
+      details: error
+    };
   }
-  if (!serviceClass || !serviceClass.identifier) return null;
-  return {
-    className: serviceClass.identifier.value,
-    methods: extractMethods(serviceClass),
-    hasInjectable,
-    importMap
-  };
 }
 function hasInjectableDecorator(decorators) {
-  return decorators?.some((d) => {
+  if (!decorators) return false;
+  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) {
+function extractMethods(classDecl, filePath) {
   const methods = [];
+  const className = classDecl.identifier?.value || "UnknownClass";
   for (const member of classDecl.body) {
-    if (member.type === "ClassMethod" && member.accessibility === "public") {
-      const method = member;
-      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
-      });
+    if (!isPublicMethod(member)) continue;
+    const method = member;
+    const methodName = getMethodName(method);
+    if (!methodName) continue;
+    const returnTypeInfo = analyzeReturnType(method);
+    if (!returnTypeInfo.isObservable && !method.function.async) {
+      throw {
+        type: "validation",
+        message: `Method ${className}.${methodName} must be async or return an Observable`,
+        filePath,
+        details: { className, methodName }
+      };
     }
+    const { paramSchemas, returnSchema } = extractSignature(
+      method.function.decorators,
+      method.function.params.length
+    );
+    methods.push({
+      name: methodName,
+      params: extractMethodParams(method.function.params),
+      returnType: returnTypeInfo.type,
+      isAsync: method.function.async,
+      isObservable: returnTypeInfo.isObservable,
+      paramSchemas,
+      returnSchema
+    });
   }
   return methods;
 }
+function isPublicMethod(member) {
+  return member.type === "ClassMethod" && (member.accessibility === "public" || !member.accessibility);
+}
+function getMethodName(method) {
+  if (method.key.type === "Identifier") {
+    return method.key.value;
+  }
+  return null;
+}
+function analyzeReturnType(method) {
+  const returnType = method.function.returnType?.typeAnnotation;
+  if (!returnType) {
+    return { type: "any", isObservable: false };
+  }
+  if (returnType.type === "TsTypeReference" && returnType.typeName.type === "Identifier" && returnType.typeName.value === "Observable") {
+    const innerType = returnType.typeParams?.params[0];
+    return {
+      type: innerType ? stringifyType(innerType) : "any",
+      isObservable: true
+    };
+  }
+  if (returnType.type === "TsTypeReference" && returnType.typeName.type === "Identifier" && returnType.typeName.value === "Promise") {
+    const innerType = returnType.typeParams?.params[0];
+    return {
+      type: innerType ? stringifyType(innerType) : "any",
+      isObservable: false
+    };
+  }
+  return {
+    type: stringifyType(returnType),
+    isObservable: false
+  };
+}
 function extractSignature(decorators, paramCount) {
   if (!decorators) return { paramSchemas: [] };
   for (const decorator of decorators) {
@@ -1023,9 +1088,14 @@ function extractSignature(decorators, paramCount) {
   return { paramSchemas: [] };
 }
 function stringifyExpression(expr) {
-  if (expr.type === "Identifier") return expr.value;
+  if (!expr) return "any";
+  if (expr.type === "Identifier") {
+    return expr.value;
+  }
   if (expr.type === "MemberExpression") {
-    return `${stringifyExpression(expr.object)}.${expr.property.value || ""}`;
+    const object = stringifyExpression(expr.object);
+    const property = expr.property.value || stringifyExpression(expr.property);
+    return `${object}.${property}`;
   }
   if (expr.type === "CallExpression") {
     const args = expr.arguments.map((a) => stringifyExpression(a.expression)).join(", ");
@@ -1036,6 +1106,13 @@ function stringifyExpression(expr) {
 function extractMethodParams(params) {
   return params.map((p) => {
     const pat = p.pat;
+    if (pat.type !== "Identifier") {
+      return {
+        name: "param",
+        type: "any",
+        decorators: []
+      };
+    }
     return {
       name: pat.value,
       type: pat.typeAnnotation ? stringifyType(pat.typeAnnotation.typeAnnotation) : "any",
@@ -1043,97 +1120,191 @@ function extractMethodParams(params) {
     };
   });
 }
-function extractReturnType(node) {
-  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) {
   if (!node) return "any";
   switch (node.type) {
     case "TsKeywordType":
       return node.kind;
     case "TsTypeReference":
+      if (node.typeName.type !== "Identifier") return "any";
       const base = node.typeName.value;
-      const args = node.typeParams ? `<${node.typeParams.params.map(stringifyType).join(", ")}>` : "";
+      const args = node.typeParams?.params ? `<${node.typeParams.params.map(stringifyType).join(", ")}>` : "";
       return base + args;
     case "TsArrayType":
       return `${stringifyType(node.elemType)}[]`;
+    case "TsUnionType":
+      return node.types.map(stringifyType).join(" | ");
+    case "TsIntersectionType":
+      return node.types.map(stringifyType).join(" & ");
     default:
       return "any";
   }
 }
+function validateServiceInfo(serviceInfo, filePath) {
+  if (!serviceInfo.className) {
+    throw {
+      type: "validation",
+      message: "Service class must have a valid name",
+      filePath
+    };
+  }
+  if (serviceInfo.methods.length === 0) {
+    console.warn(
+      `Warning: Service ${serviceInfo.className} has no public methods`
+    );
+  }
+  serviceInfo.methods.forEach((method) => {
+    if (method.params.length > 0 && method.paramSchemas.length === 0) {
+      console.warn(
+        `Warning: Method ${serviceInfo.className}.${method.name} has parameters but no @Signature validation`
+      );
+    }
+  });
+}
 function generateControllerCode(serviceInfo, filePath) {
   const serviceName = serviceInfo.className;
-  const controllerName = serviceName.replace(/Service$/, "AutoController");
-  const serviceImportPath = `./${path4.basename(filePath).replace(/\.ts$/, "")}`;
+  const controllerName = serviceName.replace(/Service$/, "GenController");
+  const serviceImportPath = getImportPath(filePath);
+  const controllerPath = serviceNameToPath(serviceName);
+  const imports = generateImports(serviceInfo, serviceName, serviceImportPath);
+  const methods = generateMethods(serviceInfo);
+  const serviceInstance = toInstanceName(serviceName);
+  return `${imports}
+
+@Controller("/${controllerPath}", {
+  providedIn: "root",
+})
+export class ${controllerName} {
+  constructor(private readonly ${serviceInstance}: ${serviceName}) {}
+
+${methods}
+}`;
+}
+function getImportPath(filePath) {
+  const basename3 = path4.basename(filePath);
+  return `./${basename3.replace(/\.tsx?$/, "")}`;
+}
+function serviceNameToPath(serviceName) {
+  return serviceName.replace(/Service$/, "").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function toInstanceName(className) {
+  return className.charAt(0).toLowerCase() + className.slice(1);
+}
+function generateImports(serviceInfo, serviceName, serviceImportPath) {
   const importGroups = /* @__PURE__ */ new Map();
   const registerIdentifier = (id) => {
     const source = serviceInfo.importMap[id] || serviceImportPath;
-    if (!importGroups.has(source)) importGroups.set(source, /* @__PURE__ */ new Set());
+    if (!importGroups.has(source)) {
+      importGroups.set(source, /* @__PURE__ */ 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");
+      if (s.includes("z.")) {
+        registerIdentifier("z");
+      }
     });
   });
-  let importStrings = `import { Controller, Post, Get, Body } from "@kithinji/orca";
+  const hasPost = serviceInfo.methods.some(
+    (m) => !m.isObservable && m.params.length > 0
+  );
+  const hasGet = serviceInfo.methods.some(
+    (m) => !m.isObservable && m.params.length === 0
+  );
+  const hasSse = serviceInfo.methods.some((m) => m.isObservable);
+  const hasSseWithParams = serviceInfo.methods.some(
+    (m) => m.isObservable && m.params.length > 0
+  );
+  const decorators = ["Controller"];
+  if (hasPost) decorators.push("Post");
+  if (hasGet) decorators.push("Get");
+  if (hasPost) decorators.push("Body");
+  if (hasSse) decorators.push("Sse");
+  if (hasSseWithParams) decorators.push("Query");
+  let importStrings = `import { ${decorators.join(
+    ", "
+  )} } from "@kithinji/orca";
 `;
   importGroups.forEach((ids, source) => {
     const filteredIds = Array.from(ids).filter((id) => id !== serviceName);
     if (filteredIds.length > 0) {
-      importStrings += `
-import { ${filteredIds.join(
+      importStrings += `import { ${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 : {};
-`;
-        m.params.forEach((p, i) => {
-          body += `    const ${p.name} = ${m.paramSchemas[i]}.parse(b.${p.name});
-`;
-        });
-      } else {
-        body += `    const { ${m.params.map((p) => p.name).join(", ")} } = body;
+      )} } from "${source}";
 `;
-      }
-    }
-    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};
-    return ${m.returnSchema}.parse(res);`;
-    } else {
-      body += `    return ${serviceCall};`;
     }
-    return `  @${hasParams ? "Post" : "Get"}("${m.name}")
-  async ${m.name}(${bodyParam}): Promise<${m.returnType}> {
+  });
+  return importStrings;
+}
+function generateMethods(serviceInfo) {
+  return serviceInfo.methods.map((m) => generateMethod(m, serviceInfo.className)).join("\n\n");
+}
+function generateMethod(method, serviceName) {
+  const hasParams = method.params.length > 0;
+  const serviceInstance = toInstanceName(serviceName);
+  if (method.isObservable) {
+    const queryParams = hasParams ? method.params.map((p) => `@Query('${p.name}') ${p.name}: ${p.type}`).join(", ") : "";
+    const body2 = generateMethodBody(method, serviceInstance, false);
+    return `  @Sse("${method.name}")
+  ${method.name}(${queryParams}): Observable<${method.returnType}> {
+${body2}
+  }`;
+  }
+  const decorator = hasParams ? "Post" : "Get";
+  const bodyParam = hasParams ? `@Body() body: any` : "";
+  const body = generateMethodBody(method, serviceInstance, true);
+  return `  @${decorator}("${method.name}")
+  async ${method.name}(${bodyParam}): Promise<${method.returnType}> {
 ${body}
   }`;
-  }).join("\n\n");
-  return `${importStrings}
-
-@Controller("/${serviceName}", {
-  providedIn: "root",
-})
-export class ${controllerName} {
-  constructor(private readonly ${serviceName.charAt(0).toLowerCase() + serviceName.slice(1)}: ${serviceName}) {}
-
-${methods}
-}`;
+}
+function generateMethodBody(method, serviceInstance, isAsync) {
+  const lines = [];
+  const hasParams = method.params.length > 0;
+  if (hasParams && method.isObservable && method.paramSchemas.length > 0) {
+    method.params.forEach((p, i) => {
+      lines.push(
+        `    const validated${capitalize(p.name)} = ${method.paramSchemas[i]}.parse(${p.name});`
+      );
+    });
+  }
+  if (hasParams && !method.isObservable) {
+    if (method.paramSchemas.length > 0) {
+      lines.push(
+        `    const b = typeof body === 'object' && body !== null ? body : {};`
+      );
+      method.params.forEach((p, i) => {
+        lines.push(
+          `    const ${p.name} = ${method.paramSchemas[i]}.parse(b.${p.name});`
+        );
+      });
+    } else {
+      const paramNames = method.params.map((p) => p.name).join(", ");
+      lines.push(`    const { ${paramNames} } = body || {};`);
+    }
+  }
+  let callArgs;
+  if (hasParams && method.isObservable && method.paramSchemas.length > 0) {
+    callArgs = method.params.map((p) => `validated${capitalize(p.name)}`).join(", ");
+  } else {
+    callArgs = method.params.map((p) => p.name).join(", ");
+  }
+  const serviceCall = `${serviceInstance}.${method.name}(${callArgs})`;
+  if (method.returnSchema && isAsync) {
+    lines.push(`    const res = await this.${serviceCall};`);
+    lines.push(`    return ${method.returnSchema}.parse(res);`);
+  } else if (isAsync) {
+    lines.push(`    return this.${serviceCall};`);
+  } else {
+    lines.push(`    return this.${serviceCall};`);
+  }
+  return lines.join("\n");
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
 }
 
 // src/plugins/generators/tsx_server_stub.ts
@@ -2378,7 +2549,7 @@ function extractMethods2(classDecl) {
         continue;
       }
       const params = extractMethodParams2(method.function.params || []);
-      const returnType = extractReturnType2(method.function.returnType);
+      const returnType = extractReturnType(method.function.returnType);
       const isAsync = method.function.async || false;
       methods.push({
         name: methodName,
@@ -2407,7 +2578,7 @@ function extractMethodParams2(params) {
   }
   return result;
 }
-function extractReturnType2(returnType) {
+function extractReturnType(returnType) {
   if (!returnType || !returnType.typeAnnotation) {
     return "any";
   }
@@ -2526,37 +2697,66 @@ ${decoratorsStr}export class ${className} extends _OrcaComponent {
 }`;
 }
 
-// src/plugins/generators/generate_rsc.ts
+// src/plugins/generators/generate_rpc.ts
 import { parseSync as parseSync4 } from "@swc/core";
-function generateRscStub(filePath, code) {
-  const ast = parseSync4(code, {
-    syntax: "typescript",
-    tsx: filePath.endsWith("x"),
-    decorators: true
-  });
-  const serviceInfo = extractServiceInfo2(ast);
-  return generateStubCode2(serviceInfo);
+function generateRpcStub(filePath, code) {
+  try {
+    const ast = parseSync4(code, {
+      syntax: "typescript",
+      tsx: filePath.endsWith("x") || filePath.endsWith(".tsx"),
+      decorators: true
+    });
+    const serviceInfo = extractServiceInfo2(ast, filePath);
+    validateServiceInfo2(serviceInfo, filePath);
+    return generateStubCode2(serviceInfo);
+  } catch (error) {
+    if (error.type) {
+      throw error;
+    }
+    throw {
+      type: "parse",
+      message: `Failed to parse TypeScript file: ${error.message}`,
+      filePath,
+      details: error
+    };
+  }
 }
-function extractServiceInfo2(ast) {
+function extractServiceInfo2(ast, filePath) {
   let serviceClass = null;
-  for (const item of ast.body) {
-    if (item.type === "ExportDeclaration" && item.declaration.type === "ClassDeclaration") {
-      const classDecl = item.declaration;
-      if (hasInjectableDecorator2(classDecl.decorators)) {
-        serviceClass = classDecl;
-        break;
+  try {
+    for (const item of ast.body) {
+      if (item.type === "ExportDeclaration" && item.declaration?.type === "ClassDeclaration") {
+        const classDecl = item.declaration;
+        if (hasInjectableDecorator2(classDecl.decorators)) {
+          serviceClass = classDecl;
+          break;
+        }
       }
     }
+    if (!serviceClass?.identifier) {
+      throw {
+        type: "validation",
+        message: "No exported class with @Injectable decorator found",
+        filePath
+      };
+    }
+    const className = serviceClass.identifier.value;
+    const methods = extractMethods3(serviceClass, className, filePath);
+    return {
+      className,
+      methods
+    };
+  } catch (error) {
+    if (error.type) {
+      throw error;
+    }
+    throw {
+      type: "parse",
+      message: `Failed to extract service info: ${error.message}`,
+      filePath,
+      details: error
+    };
   }
-  if (!serviceClass || !serviceClass.identifier) {
-    throw new Error("Service class is undefined");
-  }
-  const className = serviceClass.identifier.value;
-  const methods = extractMethods3(serviceClass);
-  return {
-    className,
-    methods
-  };
 }
 function hasInjectableDecorator2(decorators) {
   if (!decorators) return false;
@@ -2573,65 +2773,81 @@ function hasInjectableDecorator2(decorators) {
     return false;
   });
 }
-function extractMethods3(classDecl) {
+function extractMethods3(classDecl, className, filePath) {
   const methods = [];
   for (const member of classDecl.body) {
-    if (member.type === "ClassMethod" && member.accessibility === "public") {
-      const method = member;
-      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 = extractMethodParams3(method.function.params || []);
-      const returnType = extractReturnType3(method.function.returnType);
-      const isAsync = method.function.async || false;
-      methods.push({
-        name: methodName,
-        params,
-        returnType,
-        isAsync
-      });
+    if (!isPublicMethod2(member)) continue;
+    const method = member;
+    const methodName = getMethodName2(method);
+    if (!methodName) continue;
+    const returnTypeInfo = analyzeReturnType2(method);
+    if (!returnTypeInfo.isObservable && !method.function.async) {
+      throw {
+        type: "validation",
+        message: `Method ${className}.${methodName} must be async or return an Observable`,
+        filePath,
+        details: { className, methodName }
+      };
     }
+    const params = extractMethodParams3(method.function.params || []);
+    methods.push({
+      name: methodName,
+      params,
+      returnType: returnTypeInfo.type,
+      isAsync: method.function.async,
+      isObservable: returnTypeInfo.isObservable
+    });
   }
   return methods;
 }
+function isPublicMethod2(member) {
+  return member.type === "ClassMethod" && (member.accessibility === "public" || !member.accessibility);
+}
+function getMethodName2(method) {
+  if (method.key.type === "Identifier") {
+    return method.key.value;
+  }
+  return null;
+}
+function analyzeReturnType2(method) {
+  const returnType = method.function.returnType?.typeAnnotation;
+  if (!returnType) {
+    return { type: "any", isObservable: false };
+  }
+  if (returnType.type === "TsTypeReference" && returnType.typeName.type === "Identifier" && returnType.typeName.value === "Observable") {
+    const innerType = returnType.typeParams?.params[0];
+    return {
+      type: innerType ? stringifyType4(innerType) : "any",
+      isObservable: true
+    };
+  }
+  if (returnType.type === "TsTypeReference" && returnType.typeName.type === "Identifier" && returnType.typeName.value === "Promise") {
+    const innerType = returnType.typeParams?.params[0];
+    return {
+      type: innerType ? stringifyType4(innerType) : "any",
+      isObservable: false
+    };
+  }
+  return {
+    type: stringifyType4(returnType),
+    isObservable: false
+  };
+}
 function extractMethodParams3(params) {
   const result = [];
   for (const param of params) {
-    if (param.type === "Parameter") {
-      const pat = param.pat;
-      if (pat.type === "Identifier") {
-        const name = pat.value;
-        const type = pat.typeAnnotation?.typeAnnotation ? stringifyType4(pat.typeAnnotation.typeAnnotation) : "any";
-        result.push({
-          name,
-          type
-        });
-      }
+    const pat = param.pat;
+    if (pat.type === "Identifier") {
+      const name = pat.value;
+      const type = pat.typeAnnotation?.typeAnnotation ? stringifyType4(pat.typeAnnotation.typeAnnotation) : "any";
+      result.push({
+        name,
+        type
+      });
     }
   }
   return result;
 }
-function extractReturnType3(returnType) {
-  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 stringifyType4(type.typeParams.params[0]);
-      }
-    }
-  }
-  return stringifyType4(type);
-}
 function stringifyType4(typeNode) {
   if (!typeNode) return "any";
   switch (typeNode.type) {
@@ -2640,7 +2856,7 @@ function stringifyType4(typeNode) {
     case "TsTypeReference":
       if (typeNode.typeName.type === "Identifier") {
         const baseName = typeNode.typeName.value;
-        if (typeNode.typeParams && typeNode.typeParams.params.length > 0) {
+        if (typeNode.typeParams?.params.length) {
           const params = typeNode.typeParams.params.map(stringifyType4).join(", ");
           return `${baseName}<${params}>`;
         }
@@ -2667,18 +2883,87 @@ function stringifyType4(typeNode) {
       return "any";
   }
 }
+function validateServiceInfo2(serviceInfo, filePath) {
+  if (!serviceInfo.className) {
+    throw {
+      type: "validation",
+      message: "Service class must have a valid name",
+      filePath
+    };
+  }
+  if (serviceInfo.methods.length === 0) {
+    console.warn(
+      `Warning: Service ${serviceInfo.className} has no public methods`
+    );
+  }
+}
 function generateStubCode2(serviceInfo) {
   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}\`, {
+  const basePath = serviceNameToPath2(className);
+  const methods = serviceInfo.methods.map((method) => generateMethod2(method, basePath)).join("\n\n");
+  const hasObservable = serviceInfo.methods.some((m) => m.isObservable);
+  const observableImport = hasObservable ? `import { Observable } from "@kithinji/orca";
+` : "";
+  return `${observableImport}import { Injectable } from "@kithinji/orca";
+
+@Injectable()
+export class ${className} {
+${methods}
+}`;
+}
+function serviceNameToPath2(serviceName) {
+  return serviceName.replace(/Service$/, "").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function generateMethod2(method, basePath) {
+  if (method.isObservable) {
+    return generateSseMethod(method, basePath);
+  }
+  const params = method.params.map((p) => `${p.name}: ${p.type}`).join(", ");
+  const hasParams = method.params.length > 0;
+  if (!hasParams) {
+    return generateGetMethod(method, basePath);
+  }
+  return generatePostMethod(method, basePath, params);
+}
+function generateSseMethod(method, basePath) {
+  const params = method.params.map((p) => `${p.name}: ${p.type}`).join(", ");
+  const hasParams = method.params.length > 0;
+  let urlBuilder;
+  if (hasParams) {
+    const queryParams = method.params.map((p) => `${p.name}=\${encodeURIComponent(${p.name})}`).join("&");
+    urlBuilder = `\`/${basePath}/${method.name}?${queryParams}\``;
+  } else {
+    urlBuilder = `\`/${basePath}/${method.name}\``;
+  }
+  return `  ${method.name}(${params}): Observable<${method.returnType}> {
+    return new Observable((observer) => {
+      const eventSource = new EventSource(${urlBuilder});
+
+      eventSource.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data);
+          observer.next(data);
+        } catch (error) {
+          observer.error?.(error);
+        }
+      };
+
+      eventSource.onerror = (error) => {
+        observer.error?.(error);
+        eventSource.close();
+      };
+
+      return () => {
+        eventSource.close();
+      };
+    });
+  }`;
+}
+function generateGetMethod(method, basePath) {
+  const params = method.params.map((p) => `${p.name}: ${p.type}`).join(", ");
+  const returnType = `Promise<${method.returnType}>`;
+  return `  async ${method.name}(${params}): ${returnType} {
+    const response = await fetch(\`/${basePath}/${method.name}\`, {
       method: 'GET',
       headers: {
         'Content-Type': 'application/json',
@@ -2691,14 +2976,17 @@ function generateStubCode2(serviceInfo) {
 
     return response.json();
   }`;
-    }
-    return `  ${asyncKeyword}${method.name}(${params}): ${returnType} {
-    const response = await fetch(\`/${className}/${method.name}\`, {
+}
+function generatePostMethod(method, basePath, params) {
+  const paramNames = method.params.map((p) => p.name).join(", ");
+  const returnType = `Promise<${method.returnType}>`;
+  return `  async ${method.name}(${params}): ${returnType} {
+    const response = await fetch(\`/${basePath}/${method.name}\`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
       },
-      body: JSON.stringify(${bodyParam}),
+      body: JSON.stringify({ ${paramNames} }),
     });
 
     if (!response.ok) {
@@ -2707,13 +2995,6 @@ function generateStubCode2(serviceInfo) {
 
     return response.json();
   }`;
-  }).join("\n\n");
-  return `import { Injectable } from "@kithinji/orca";
-
-@Injectable()
-export class ${className} {
-${methods}
-}`;
 }
 
 // src/plugins/my.ts
@@ -2830,8 +3111,8 @@ var ClientBuildTransformer = class {
     const scSource = generateServerComponent(path15, source);
     return swcTransform(scSource, path15);
   }
-  async transformPublicFileRsc(node, source, path15) {
-    const stubSource = generateRscStub(path15, source);
+  async transformPublicFileRpc(node, source, path15) {
+    const stubSource = generateRpcStub(path15, source);
     return swcTransform(stubSource, path15);
   }
   async transformSharedCode(source, path15) {
@@ -2853,7 +3134,7 @@ var ClientBuildTransformer = class {
       }
     }
     if (directive === "public") {
-      return this.transformPublicFileRsc(node, source, path15);
+      return this.transformPublicFileRpc(node, source, path15);
     }
     if (directive === null) {
       return this.transformSharedCode(source, path15);
@@ -3484,7 +3765,7 @@ Processing dependencies for "${name}": [${component.dependencies.join(
   }
 }
 function updateModuleWithComponent(moduleContent, componentName) {
-  const className = capitalize(componentName);
+  const className = capitalize2(componentName);
   const importPath = `./component/${componentName}.component`;
   const sourceFile = ts2.createSourceFile(
     "component.module.ts",
@@ -3640,7 +3921,7 @@ function ensureComponentModuleImported(appModuleContent) {
 function ensureInImportsArray(content, sourceFile) {
   return addToDecoratorArray(content, sourceFile, "imports", "ComponentModule");
 }
-function capitalize(str) {
+function capitalize2(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 function createModule() {
@@ -5578,7 +5859,7 @@ Deployment Failed: ${err.message}`));
 // src/main.ts
 import chalk2 from "chalk";
 var program = new Command();
-program.name("pod").description("Pod cli tool").version("1.0.23");
+program.name("pod").description("Pod cli tool").version("1.0.24");
 program.command("new <name>").description("Start a new Orca Project").action(async (name) => {
   await addNew(name);
   const appDir = path14.resolve(process.cwd());