@kithinji/pod 1.0.42 → 1.0.47

package/dist/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -499,7 +500,7 @@ function resolveImportFullPath(symbolName, sourceFile, compilerOptions) {
   };
 }
 function isNpmPackage(importPath) {
-  return !importPath.startsWith(".") && !importPath.startsWith("/") && !path3.isAbsolute(importPath);
+  return !importPath.startsWith(".") && !importPath.startsWith("/") && !importPath.startsWith("@/") && !path3.isAbsolute(importPath);
 }
 function findVariableDeclarationInFile(variableName, sourceFile) {
   let found;
@@ -929,6 +930,7 @@ async function expandMacros(source, filePath, projectRoot = process.cwd()) {
 
 // src/plugins/generators/generate_controller.ts
 import * as path4 from "path";
+import { printSync } from "@swc/core";
 
 // src/plugins/generators/utils.ts
 import {
@@ -963,8 +965,20 @@ function hasInjectableDecorator(decorators) {
     return expr.type === "Identifier" && expr.value === "Injectable" || expr.type === "CallExpression" && expr.callee.type === "Identifier" && expr.callee.value === "Injectable";
   });
 }
+function isClassMethod(member) {
+  return member.type === "ClassMethod";
+}
+function isClassProperty(member) {
+  return member.type === "ClassProperty";
+}
+function isConstructor(member) {
+  return member.type === "Constructor";
+}
 function isPublicMethod(member) {
-  return member.type === "ClassMethod" && (member.accessibility === "public" || !member.accessibility);
+  return member.type === "ClassMethod" && (member.accessibility === "public" || member.accessibility === void 0);
+}
+function isPrivateMethod(member) {
+  return member.type === "ClassMethod" && member.accessibility === "private";
 }
 function getMethodName(method) {
   if (method.key.type === "Identifier") {
@@ -1026,23 +1040,36 @@ function analyzeReturnType(method) {
     isSubjectLike: false
   };
 }
+function stringifyEntityName(node) {
+  if (!node) return "any";
+  switch (node.type) {
+    case "Identifier":
+      return node.value;
+    case "TsQualifiedName":
+      return `${stringifyEntityName(node.left)}.${stringifyEntityName(
+        node.right
+      )}`;
+    default:
+      return "any";
+  }
+}
 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;
+    case "TsTypeReference": {
+      const base = stringifyEntityName(node.typeName);
       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(" & ");
-    case "TsTypeLiteral":
+    case "TsTypeLiteral": {
       const props = node.members.map((member) => {
         if (member.type === "TsPropertySignature") {
           const key = member.key.type === "Identifier" ? member.key.value : "";
@@ -1052,10 +1079,55 @@ function stringifyType(node) {
         return "";
       }).filter(Boolean);
       return `{ ${props.join("; ")} }`;
+    }
     default:
       return "any";
   }
 }
+function stringifyDecorator(decorator) {
+  const expr = decorator.expression;
+  if (expr.type === "Identifier") {
+    return `@${expr.value}`;
+  }
+  if (expr.type === "CallExpression" && expr.callee.type === "Identifier") {
+    const args = expr.arguments.map((arg) => stringifyExpression(arg.expression)).join(", ");
+    return args ? `@${expr.callee.value}(${args})` : `@${expr.callee.value}()`;
+  }
+  return "@Unknown";
+}
+function shouldLiftDecorator(decoratorString) {
+  const match = decoratorString.match(/^@(_)?([A-Za-z0-9]+)/);
+  if (!match) return false;
+  const prefix = match[1];
+  return !prefix;
+}
+function extractMethodDecorators(method) {
+  const decorators = [];
+  if (method.function.decorators) {
+    for (const decorator of method.function.decorators) {
+      decorators.push(stringifyDecorator(decorator));
+    }
+  }
+  return decorators;
+}
+function extractParamDecorators(param) {
+  const decorators = [];
+  if (param.decorators) {
+    for (const decorator of param.decorators) {
+      decorators.push(stringifyDecorator(decorator));
+    }
+  }
+  return decorators;
+}
+function extractPropertyDecorators(property) {
+  const decorators = [];
+  if (property.decorators) {
+    for (const decorator of property.decorators) {
+      decorators.push(stringifyDecorator(decorator));
+    }
+  }
+  return decorators;
+}
 function extractMethodParams(params) {
   return params.map((p) => {
     const pat = p.pat;
@@ -1063,17 +1135,222 @@ function extractMethodParams(params) {
       return {
         name: "param",
         type: "any",
-        decorators: []
+        decorators: extractParamDecorators(p)
       };
     }
     return {
       name: pat.value,
       type: pat.typeAnnotation ? stringifyType(pat.typeAnnotation.typeAnnotation) : "any",
-      decorators: []
+      decorators: extractParamDecorators(p)
     };
   });
 }
-function extractSignature(decorators, paramCount) {
+function extractIdentifiersFromQualifiedName(node) {
+  const identifiers = [];
+  if (node.type === "Identifier") {
+    identifiers.push(node.value);
+  } else if (node.type === "TsQualifiedName") {
+    identifiers.push(...extractIdentifiersFromQualifiedName(node.left));
+    identifiers.push(...extractIdentifiersFromQualifiedName(node.right));
+  }
+  return identifiers;
+}
+function extractIdentifiersFromType(node) {
+  if (!node) return [];
+  const identifiers = [];
+  switch (node.type) {
+    case "TsKeywordType":
+      return [];
+    case "TsTypeReference": {
+      if (node.typeName.type === "Identifier") {
+        identifiers.push(node.typeName.value);
+      } else if (node.typeName.type === "TsQualifiedName") {
+        identifiers.push(...extractIdentifiersFromQualifiedName(node.typeName));
+      }
+      if (node.typeParams?.params) {
+        for (const param of node.typeParams.params) {
+          identifiers.push(...extractIdentifiersFromType(param));
+        }
+      }
+      break;
+    }
+    case "TsArrayType":
+      identifiers.push(...extractIdentifiersFromType(node.elemType));
+      break;
+    case "TsUnionType":
+    case "TsIntersectionType":
+      for (const type of node.types) {
+        identifiers.push(...extractIdentifiersFromType(type));
+      }
+      break;
+    case "TsTypeLiteral":
+      for (const member of node.members) {
+        if (member.type === "TsPropertySignature" && member.typeAnnotation) {
+          identifiers.push(
+            ...extractIdentifiersFromType(member.typeAnnotation.typeAnnotation)
+          );
+        }
+      }
+      break;
+    case "TsTupleType":
+      if (node.elemTypes) {
+        for (const elem of node.elemTypes) {
+          identifiers.push(...extractIdentifiersFromType(elem));
+        }
+      }
+      break;
+  }
+  return identifiers;
+}
+function extractIdentifiersFromDecorator(decorator) {
+  const identifiers = [];
+  const expr = decorator.expression;
+  if (expr.type === "Identifier") {
+    identifiers.push(expr.value);
+  } else if (expr.type === "CallExpression") {
+    if (expr.callee.type === "Identifier") {
+      identifiers.push(expr.callee.value);
+    }
+    for (const arg of expr.arguments) {
+      identifiers.push(...extractIdentifiersFromExpression(arg.expression));
+    }
+  }
+  return identifiers;
+}
+function extractIdentifiersFromExpression(expr) {
+  if (!expr) return [];
+  const identifiers = [];
+  switch (expr.type) {
+    case "Identifier":
+      identifiers.push(expr.value);
+      break;
+    case "MemberExpression":
+      identifiers.push(...extractIdentifiersFromExpression(expr.object));
+      if (expr.property.type === "Identifier") {
+        identifiers.push(expr.property.value);
+      }
+      break;
+    case "CallExpression":
+      identifiers.push(...extractIdentifiersFromExpression(expr.callee));
+      for (const arg of expr.arguments) {
+        identifiers.push(...extractIdentifiersFromExpression(arg.expression));
+      }
+      break;
+  }
+  return identifiers;
+}
+function resolveImports(identifiers, importMap) {
+  const imports = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const identifier of identifiers) {
+    if (seen.has(identifier)) continue;
+    const source = importMap[identifier];
+    if (source) {
+      imports.push({ identifier, source });
+      seen.add(identifier);
+    }
+  }
+  return imports;
+}
+function extractClassProperties(classDecl, importMap) {
+  const properties = [];
+  if (!classDecl.body || !Array.isArray(classDecl.body)) {
+    return properties;
+  }
+  for (const member of classDecl.body) {
+    if (!isClassProperty(member)) continue;
+    const property = member;
+    if (property.key.type !== "Identifier") continue;
+    const propertyName = property.key.value;
+    const propertyType = property.typeAnnotation ? stringifyType(property.typeAnnotation.typeAnnotation) : "any";
+    const identifiers = [];
+    if (property.typeAnnotation) {
+      identifiers.push(
+        ...extractIdentifiersFromType(property.typeAnnotation.typeAnnotation)
+      );
+    }
+    if (property.decorators) {
+      for (const decorator of property.decorators) {
+        identifiers.push(...extractIdentifiersFromDecorator(decorator));
+      }
+    }
+    const imports = resolveImports(identifiers, importMap);
+    properties.push({
+      name: propertyName,
+      type: propertyType,
+      isReadonly: property.readonly || false,
+      isStatic: property.isStatic || false,
+      accessibility: property.accessibility,
+      decorators: extractPropertyDecorators(property),
+      hasInitializer: !!property.value,
+      imports
+    });
+  }
+  return properties;
+}
+function extractConstructorParams(classDecl, importMap) {
+  const params = [];
+  if (!classDecl.body || !Array.isArray(classDecl.body)) {
+    return params;
+  }
+  for (const member of classDecl.body) {
+    if (!isConstructor(member)) continue;
+    const constructor = member;
+    for (const param of constructor.params) {
+      if (param.type === "TsParameterProperty") {
+        const tsParam = param;
+        const pat = tsParam.param;
+        if (pat.type !== "Identifier") continue;
+        const identifiers = [];
+        if (pat.typeAnnotation) {
+          identifiers.push(
+            ...extractIdentifiersFromType(pat.typeAnnotation.typeAnnotation)
+          );
+        }
+        if (tsParam.decorators) {
+          for (const decorator of tsParam.decorators) {
+            identifiers.push(...extractIdentifiersFromDecorator(decorator));
+          }
+        }
+        const imports = resolveImports(identifiers, importMap);
+        params.push({
+          name: pat.value,
+          type: pat.typeAnnotation ? stringifyType(pat.typeAnnotation.typeAnnotation) : "any",
+          accessibility: tsParam.accessibility,
+          isReadonly: tsParam.readonly || false,
+          decorators: extractParamDecorators(tsParam),
+          imports
+        });
+      } else if (param.type === "Parameter") {
+        const regularParam = param;
+        const pat = regularParam.pat;
+        if (pat.type !== "Identifier") continue;
+        const identifiers = [];
+        if (pat.typeAnnotation) {
+          identifiers.push(
+            ...extractIdentifiersFromType(pat.typeAnnotation.typeAnnotation)
+          );
+        }
+        if (regularParam.decorators) {
+          for (const decorator of regularParam.decorators) {
+            identifiers.push(...extractIdentifiersFromDecorator(decorator));
+          }
+        }
+        const imports = resolveImports(identifiers, importMap);
+        params.push({
+          name: pat.value,
+          type: pat.typeAnnotation ? stringifyType(pat.typeAnnotation.typeAnnotation) : "any",
+          accessibility: void 0,
+          isReadonly: false,
+          decorators: extractParamDecorators(regularParam),
+          imports
+        });
+      }
+    }
+  }
+  return params;
+}
+function extractSignature(decorators, paramCount, className, methodName, filePath) {
   if (!decorators) return { paramSchemas: [] };
   for (const decorator of decorators) {
     const expr = decorator.expression;
@@ -1083,6 +1360,14 @@ function extractSignature(decorators, paramCount) {
       const schemaStrings = args.map(
         (arg) => stringifyExpression(arg.expression)
       );
+      if (paramCount === 0 && args.length === 1) {
+        return { paramSchemas: [], returnSchema: schemaStrings[0] };
+      }
+      if (args.length !== paramCount + 1) {
+        console.warn(
+          `Warning: Method ${className}.${methodName} has ${paramCount} parameter(s) but @Signature has ${args.length} argument(s). Expected ${paramCount + 1} (${paramCount} param schema(s) + 1 return schema).`
+        );
+      }
       if (args.length === 1) {
         return { paramSchemas: [], returnSchema: schemaStrings[0] };
       }
@@ -1110,15 +1395,36 @@ function stringifyExpression(expr) {
   }
   return "any";
 }
-function extractMethods(classDecl, filePath, includeSignatures = true) {
+function extractMethods(classDecl, filePath, includeSignatures = true, includeHeaders = false) {
   const methods = [];
   const className = classDecl.identifier?.value || "UnknownClass";
+  if (!classDecl.body || !Array.isArray(classDecl.body)) {
+    return methods;
+  }
   for (const member of classDecl.body) {
-    if (!isPublicMethod(member)) continue;
+    if (!isClassMethod(member)) continue;
     const method = member;
     const methodName = getMethodName(method);
     if (!methodName) continue;
+    const endsWithHeaders = methodName.endsWith("Headers");
     const returnTypeInfo = analyzeReturnType(method);
+    if (isPrivateMethod(member) && includeHeaders && endsWithHeaders) {
+      methods.push({
+        name: methodName,
+        params: extractMethodParams(method.function.params),
+        returnType: returnTypeInfo.type,
+        isAsync: method.function.async,
+        isStreamable: returnTypeInfo.isStreamable,
+        streamType: returnTypeInfo.streamType,
+        paramSchemas: [],
+        returnSchema: void 0,
+        decorators: void 0,
+        lift: true,
+        ast: method
+      });
+      continue;
+    }
+    if (!isPublicMethod(member)) continue;
     if (!returnTypeInfo.isStreamable && !method.function.async) {
       throw {
         type: "validation",
@@ -1131,7 +1437,10 @@ function extractMethods(classDecl, filePath, includeSignatures = true) {
     }
     const signatures = includeSignatures ? extractSignature(
       method.function.decorators,
-      method.function.params.length
+      method.function.params.length,
+      className,
+      methodName,
+      filePath
     ) : { paramSchemas: [] };
     methods.push({
       name: methodName,
@@ -1141,11 +1450,41 @@ function extractMethods(classDecl, filePath, includeSignatures = true) {
       isStreamable: returnTypeInfo.isStreamable,
       streamType: returnTypeInfo.streamType,
       paramSchemas: signatures.paramSchemas,
-      returnSchema: signatures.returnSchema
+      returnSchema: signatures.returnSchema,
+      decorators: extractMethodDecorators(method),
+      lift: false,
+      ast: method
     });
   }
   return methods;
 }
+function removeLiftedDecoratorsFromAST(ast) {
+  const clonedAst = JSON.parse(JSON.stringify(ast));
+  for (const item of clonedAst.body) {
+    if (item.type === "ExportDeclaration" && item.declaration?.type === "ClassDeclaration") {
+      const classDecl = item.declaration;
+      if (hasInjectableDecorator(classDecl.decorators)) {
+        for (const member of classDecl.body) {
+          if (member.type === "ClassMethod" && (member.accessibility === "public" || member.accessibility === void 0)) {
+            const method = member;
+            if (method.function.decorators) {
+              method.function.decorators = method.function.decorators.filter(
+                (decorator) => {
+                  const decoratorStr = stringifyDecorator(decorator);
+                  return !shouldLiftDecorator(decoratorStr);
+                }
+              );
+              if (method.function.decorators.length === 0) {
+                delete method.function.decorators;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return clonedAst;
+}
 function serviceNameToPath(serviceName) {
   return serviceName.replace(/Service$/, "").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
 }
@@ -1169,23 +1508,43 @@ function validateServiceInfo(serviceInfo, filePath) {
     );
   }
   serviceInfo.methods.forEach((method) => {
-    if (method.params.length > 0 && method.paramSchemas?.length === 0) {
+    if (method.params.length > 0 && method.paramSchemas?.length === 0 && !method.returnSchema) {
       console.warn(
-        `Warning: Method ${serviceInfo.className}.${method.name} has parameters but no @Signature validation`
+        `Warning: Method ${serviceInfo.className}.${method.name} has ${method.params.length} parameter(s) but no @Signature validation`
       );
     }
   });
 }
-function extractServiceInfo(ast, filePath, includeSignatures = true) {
+function extractServiceInfo(ast, filePath, includeSignatures = true, includeHeaders = false, includeFields = false) {
   try {
     const serviceClass = findInjectableClass(ast);
     const importMap = extractImportMap(ast);
     if (!serviceClass?.identifier) {
       return null;
     }
+    if (!serviceClass.body) {
+      console.warn(
+        `Warning: Service class ${serviceClass.identifier.value} has no body`
+      );
+      return {
+        className: serviceClass.identifier.value,
+        methods: [],
+        properties: [],
+        constructorParams: [],
+        hasInjectable: true,
+        importMap
+      };
+    }
     return {
       className: serviceClass.identifier.value,
-      methods: extractMethods(serviceClass, filePath, includeSignatures),
+      methods: extractMethods(
+        serviceClass,
+        filePath,
+        includeSignatures,
+        includeHeaders
+      ),
+      properties: includeFields ? extractClassProperties(serviceClass, importMap) : [],
+      constructorParams: includeFields ? extractConstructorParams(serviceClass, importMap) : [],
       hasInjectable: true,
       importMap
     };
@@ -1203,12 +1562,18 @@ function extractServiceInfo(ast, filePath, includeSignatures = true) {
 function generateController(filePath, code) {
   try {
     const ast = parseTypeScript(filePath, code);
-    const serviceInfo = extractServiceInfo(ast, filePath, true);
+    const serviceInfo = extractServiceInfo(ast, filePath, true, false);
     if (!serviceInfo || !serviceInfo.hasInjectable) {
       return null;
     }
     validateServiceInfo(serviceInfo, filePath);
-    return generateControllerCode(serviceInfo, filePath);
+    const transformedAst = removeLiftedDecoratorsFromAST(ast);
+    const transformedServiceCode = printSync(transformedAst).code;
+    const controllerCode = generateControllerCode(serviceInfo, filePath);
+    return {
+      controllerCode,
+      transformedServiceCode
+    };
   } catch (error) {
     if (error.type) {
       throw error;
@@ -1231,7 +1596,7 @@ function generateControllerCode(serviceInfo, filePath) {
   const serviceInstance = toInstanceName(serviceName);
   return `${imports}
 
-@Controller("/${controllerPath}", {
+@Controller("/api/${controllerPath}", {
   providedIn: "root",
 })
 export class ${controllerName} {
@@ -1276,16 +1641,40 @@ function generateImports(serviceInfo, serviceName, serviceImportPath) {
   const hasStreamableWithParams = serviceInfo.methods.some(
     (m) => m.isStreamable && m.params.length > 0
   );
-  const decorators = ["Controller"];
+  const hasFileUpload = serviceInfo.methods.some((m) => hasMulterFileParams(m));
+  const hasSingleFileUpload = serviceInfo.methods.some(
+    (m) => getFileParams(m).length === 1 && !isArrayFileParam(getFileParams(m)[0])
+  );
+  const hasMultipleFilesUpload = serviceInfo.methods.some(
+    (m) => getFileParams(m).length === 1 && isArrayFileParam(getFileParams(m)[0])
+  );
+  const hasMultipleFileFields = serviceInfo.methods.some(
+    (m) => getFileParams(m).length > 1
+  );
+  const decorators = ["Controller", "Req"];
   if (hasPost) decorators.push("Post");
   if (hasGet) decorators.push("Get");
   if (hasPost) decorators.push("Body");
   if (hasSse) decorators.push("Sse");
   if (hasStreamableWithParams) decorators.push("Query");
+  if (hasFileUpload) decorators.push("UseInterceptors");
+  if (hasSingleFileUpload) decorators.push("UploadedFile");
+  if (hasMultipleFilesUpload || hasMultipleFileFields)
+    decorators.push("UploadedFiles");
   let importStrings = `import { ${decorators.join(
     ", "
   )} } from "@kithinji/orca";
 `;
+  if (hasFileUpload) {
+    const interceptors = [];
+    if (hasSingleFileUpload) interceptors.push("FileInterceptor");
+    if (hasMultipleFilesUpload) interceptors.push("FilesInterceptor");
+    if (hasMultipleFileFields) interceptors.push("FileFieldsInterceptor");
+    importStrings += `import { ${interceptors.join(
+      ", "
+    )} } from "@kithinji/express";
+`;
+  }
   importGroups.forEach((ids, source) => {
     const filteredIds = Array.from(ids).filter((id) => id !== serviceName);
     if (filteredIds.length > 0) {
@@ -1297,32 +1686,175 @@ function generateImports(serviceInfo, serviceName, serviceImportPath) {
   });
   return importStrings;
 }
+function hasMulterFileParams(method) {
+  return method.params.some((param) => {
+    return param.type === "Array<Express.Multer.File>" || param.type === "Express.Multer.File[]" || param.type === "Express.Multer.File";
+  });
+}
+function getFileParams(method) {
+  return method.params.filter(
+    (p) => p.type === "Array<Express.Multer.File>" || p.type === "Express.Multer.File[]" || p.type === "Express.Multer.File"
+  ).map((p) => ({
+    name: p.name,
+    type: p.type,
+    isArray: p.type.includes("Array") || p.type.includes("[]")
+  }));
+}
+function isArrayFileParam(param) {
+  return param.isArray;
+}
+function getNonFileParams(method) {
+  return method.params.filter(
+    (p) => p.type !== "Array<Express.Multer.File>" && p.type !== "Express.Multer.File[]" && p.type !== "Express.Multer.File"
+  );
+}
 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);
+  const fileParams = getFileParams(method);
+  const hasFileParams = fileParams.length > 0;
+  const liftedDecorators = method.decorators?.filter(shouldLiftDecorator).map((d) => `  ${d}`).join("\n") || "";
   if (method.isStreamable) {
+    if (hasFileParams) {
+      throw new Error(
+        `Method '${method.name}' cannot have file parameters for streaming endpoints`
+      );
+    }
+    const reqParam2 = `@Req() request: Request`;
     const queryParams = hasParams ? method.params.map((p) => `@Query('${p.name}') ${p.name}: ${p.type}`).join(", ") : "";
+    const allParams2 = [reqParam2, queryParams].filter(Boolean).join(", ");
     const body2 = generateMethodBody(method, serviceInstance, false);
     const returnTypeName = method.streamType || "Observable";
-    return `  @Sse("${method.name}")
-  ${method.name}(${queryParams}): ${returnTypeName}<${method.returnType}> {
+    const decoratorPrefix2 = liftedDecorators ? `${liftedDecorators}
+` : "";
+    return `${decoratorPrefix2}  @Sse("${method.name}")
+  ${method.name}(${allParams2}): ${returnTypeName}<${method.returnType}> {
 ${body2}
   }`;
   }
+  if (hasFileParams) {
+    return generateFileUploadMethod(
+      method,
+      serviceInstance,
+      fileParams,
+      liftedDecorators
+    );
+  }
   const decorator = hasParams ? "Post" : "Get";
+  const reqParam = `@Req() request: Request`;
   const bodyParam = hasParams ? `@Body() body: any` : "";
+  const allParams = [reqParam, bodyParam].filter(Boolean).join(", ");
   const body = generateMethodBody(method, serviceInstance, true);
-  return `  @${decorator}("${method.name}")
-  async ${method.name}(${bodyParam}): Promise<${method.returnType}> {
+  const decoratorPrefix = liftedDecorators ? `${liftedDecorators}
+` : "";
+  return `${decoratorPrefix}  @${decorator}("${method.name}")
+  async ${method.name}(${allParams}): Promise<${method.returnType}> {
 ${body}
   }`;
 }
+function generateFileUploadMethod(method, serviceInstance, fileParams, liftedDecorators) {
+  const nonFileParams = getNonFileParams(method);
+  const interceptorDecorator = generateInterceptorDecorator(fileParams);
+  const methodParams = generateFileMethodParams(fileParams, nonFileParams);
+  const allParams = [`@Req() request: Request`, methodParams].filter(Boolean).join(", ");
+  const body = generateFileMethodBody(
+    method,
+    serviceInstance,
+    fileParams,
+    nonFileParams
+  );
+  const decoratorPrefix = liftedDecorators ? `${liftedDecorators}
+` : "";
+  return `${decoratorPrefix}${interceptorDecorator}  @Post("${method.name}")
+  async ${method.name}(${allParams}): Promise<${method.returnType}> {
+${body}
+  }`;
+}
+function generateInterceptorDecorator(fileParams) {
+  if (fileParams.length === 1) {
+    const param = fileParams[0];
+    if (param.isArray) {
+      return `  @UseInterceptors(FilesInterceptor("${param.name}"))
+`;
+    } else {
+      return `  @UseInterceptors(FileInterceptor("${param.name}"))
+`;
+    }
+  } else {
+    const fields = fileParams.map((p) => `{ name: "${p.name}" }`).join(", ");
+    return `  @UseInterceptors(FileFieldsInterceptor([${fields}]))
+`;
+  }
+}
+function generateFileMethodParams(fileParams, nonFileParams) {
+  const params = [];
+  if (fileParams.length === 1) {
+    const param = fileParams[0];
+    const decorator = param.isArray ? "@UploadedFiles()" : "@UploadedFile()";
+    params.push(`${decorator} ${param.name}: ${param.type}`);
+  } else if (fileParams.length > 1) {
+    params.push(
+      `@UploadedFiles() files: Record<string, Express.Multer.File[]>`
+    );
+  }
+  if (nonFileParams.length > 0) {
+    params.push(`@Body() body: any`);
+  }
+  return params.join(", ");
+}
+function generateFileMethodBody(method, serviceInstance, fileParams, nonFileParams) {
+  const lines = [];
+  lines.push(`    this.${serviceInstance}.request = request;`);
+  if (fileParams.length > 1) {
+    fileParams.forEach((p) => {
+      if (p.isArray) {
+        lines.push(`    const ${p.name} = files["${p.name}"] || [];`);
+      } else {
+        lines.push(
+          `    const ${p.name} = files["${p.name}"]?.[0] || files["${p.name}"];`
+        );
+      }
+    });
+  }
+  if (nonFileParams.length > 0) {
+    const nonFileSchemas = method.paramSchemas.filter((_, i) => {
+      const param = method.params[i];
+      return !fileParams.some((fp) => fp.name === param.name);
+    });
+    if (nonFileSchemas.length > 0 && nonFileSchemas.some((s) => s)) {
+      lines.push(
+        `    const b = typeof body === 'object' && body !== null ? body : {};`
+      );
+      nonFileParams.forEach((p) => {
+        const schemaIndex = method.params.findIndex((mp) => mp.name === p.name);
+        if (method.paramSchemas[schemaIndex]) {
+          lines.push(
+            `    const ${p.name} = ${method.paramSchemas[schemaIndex]}.parse(b.${p.name});`
+          );
+        }
+      });
+    } else {
+      const paramNames = nonFileParams.map((p) => p.name).join(", ");
+      lines.push(`    const { ${paramNames} } = body || {};`);
+    }
+  }
+  const callArgs = method.params.map((p) => p.name).join(", ");
+  const serviceCall = `${serviceInstance}.${method.name}(${callArgs})`;
+  if (method.returnSchema) {
+    lines.push(`    const res = await this.${serviceCall};`);
+    lines.push(`    return ${method.returnSchema}.parse(res);`);
+  } else {
+    lines.push(`    return this.${serviceCall};`);
+  }
+  return lines.join("\n");
+}
 function generateMethodBody(method, serviceInstance, isAsync) {
   const lines = [];
   const hasParams = method.params.length > 0;
+  lines.push(`    this.${serviceInstance}.request = request;`);
   if (hasParams && method.isStreamable && method.paramSchemas.length > 0) {
     method.params.forEach((p, i) => {
       lines.push(
@@ -1366,7 +1898,7 @@ function generateMethodBody(method, serviceInstance, isAsync) {
 // src/plugins/generators/tsx_server_stub.ts
 import * as path5 from "path";
 import { createHash } from "crypto";
-import { parseSync as parseSync2, printSync } from "@swc/core";
+import { parseSync as parseSync2, printSync as printSync2 } from "@swc/core";
 function generateServerStub(filePath, code) {
   const hash = createHash("md5").update(filePath).digest("hex").slice(0, 8);
   const relativeFromSrc = filePath.split("/src/")[1];
@@ -1412,7 +1944,7 @@ function generateServerStub(filePath, code) {
       preservedNodes.push(item);
     }
   }
-  const preservedCode = preservedNodes.length > 0 ? printSync({
+  const preservedCode = preservedNodes.length > 0 ? printSync2({
     type: "Module",
     span: ast.span,
     body: preservedNodes,
@@ -1445,7 +1977,7 @@ function extractClassStub(classDecl) {
   const constructorParams = [];
   if (classDecl.decorators) {
     for (const dec of classDecl.decorators) {
-      const str = stringifyDecorator(dec);
+      const str = stringifyDecorator2(dec);
       if (str) decorators.push(str);
     }
   }
@@ -1468,8 +2000,8 @@ function extractClassStub(classDecl) {
     constructorParams
   };
 }
-function stringifyDecorator(decorator) {
-  const exprCode = printSync({
+function stringifyDecorator2(decorator) {
+  const exprCode = printSync2({
     type: "Module",
     span: { start: 0, end: 0, ctxt: 0 },
     body: [
@@ -1504,7 +2036,7 @@ function stringifyParam(param) {
   let decorators = [];
   if (param.decorators) {
     for (const d of param.decorators) {
-      const str = stringifyDecorator(d);
+      const str = stringifyDecorator2(d);
       if (str) decorators.push(str);
     }
   }
@@ -1607,9 +2139,6 @@ var NodeTypeGuards = class {
   isSignalMember(expr) {
     return this.t.isMemberExpression(expr) && this.t.isIdentifier(expr.property, { name: "value" });
   }
-  isBehaviorSubjectMember(expr) {
-    return this.t.isMemberExpression(expr) && this.t.isIdentifier(expr.property, { name: "$value" });
-  }
 };
 var ASTUtilities = class {
   constructor(t, guards) {
@@ -1617,7 +2146,7 @@ var ASTUtilities = class {
     this.guards = guards;
   }
   getObject(expr) {
-    if (this.guards.isSignalMember(expr) || this.guards.isBehaviorSubjectMember(expr)) {
+    if (this.guards.isSignalMember(expr)) {
       return expr.object;
     }
     return expr;
@@ -1655,24 +2184,12 @@ var ASTUtilities = class {
     }
     return expr;
   }
-  insertBeforeReturn(body, statements) {
-    const returnIndex = body.findIndex(
-      (stmt) => this.t.isReturnStatement(stmt)
-    );
-    if (returnIndex !== -1) {
-      body.splice(returnIndex, 0, ...statements);
-    } else {
-      body.push(...statements);
-    }
-  }
   addEffectCleanup(scope, effectCall) {
     const cleanupId = scope.generateUidIdentifier("cleanup");
     return [
-      // const _cleanup1 = $effect(...)
       this.t.variableDeclaration("const", [
         this.t.variableDeclarator(cleanupId, effectCall)
       ]),
-      // self.__cleanup = [...(self.__cleanup || []), _cleanup1]
       this.t.expressionStatement(
         this.t.assignmentExpression(
           "=",
@@ -1785,81 +2302,12 @@ var JSXUtilities = class {
     return svgTags.has(tag);
   }
 };
-var ObservableManager = class {
-  constructor(t, guards) {
-    this.t = t;
-    this.guards = guards;
-  }
-  getObservableKey(expr) {
-    return this.stringifyNode(expr);
-  }
-  stringifyNode(node) {
-    if (!node) return "";
-    if (this.t.isThisExpression(node)) return "this";
-    if (this.t.isIdentifier(node)) return node.name;
-    if (this.t.isMemberExpression(node)) {
-      const obj = this.stringifyNode(node.object);
-      const prop = node.computed ? `[${this.stringifyNode(node.property)}]` : `.${node.property.name}`;
-      return obj + prop;
-    }
-    if (this.t.isCallExpression(node)) {
-      const callee = this.stringifyNode(node.callee);
-      const args = node.arguments.map((arg) => this.stringifyNode(arg)).join(",");
-      return `${callee}(${args})`;
-    }
-    if (this.t.isStringLiteral(node)) return `"${node.value}"`;
-    if (this.t.isNumericLiteral(node)) return String(node.value);
-    return node.type + JSON.stringify(node.name || node.value || "");
-  }
-  collectObservables(node, observables, astUtils) {
-    this.walkNode(node, (n) => {
-      if (this.guards.isBehaviorSubjectMember(n)) {
-        const observable = astUtils.replaceThisWithSelf(
-          n.object
-        );
-        const key = this.getObservableKey(observable);
-        if (!observables.has(key)) {
-          observables.set(key, observable);
-        }
-      }
-    });
-  }
-  replaceObservablesWithSignals(node, observableSignals, astUtils) {
-    const cloned = this.t.cloneNode(node, true);
-    this.walkNode(cloned, (n) => {
-      if (this.guards.isBehaviorSubjectMember(n)) {
-        const observable = astUtils.replaceThisWithSelf(n.object);
-        const key = this.getObservableKey(observable);
-        const signalId = observableSignals.get(key);
-        if (signalId) {
-          n.object = signalId;
-          n.property = this.t.identifier("value");
-        }
-      }
-    });
-    return cloned;
-  }
-  walkNode(node, callback) {
-    if (!node || typeof node !== "object") return;
-    callback(node);
-    for (const key in node) {
-      if (["loc", "start", "end", "extra"].includes(key)) continue;
-      const value = node[key];
-      if (Array.isArray(value)) {
-        value.forEach((item) => this.walkNode(item, callback));
-      } else if (value && typeof value === "object") {
-        this.walkNode(value, callback);
-      }
-    }
-  }
-};
 var ElementTransformer = class {
-  constructor(t, guards, astUtils, jsxUtils, observableManager) {
+  constructor(t, guards, astUtils, jsxUtils) {
     this.t = t;
     this.guards = guards;
     this.astUtils = astUtils;
     this.jsxUtils = jsxUtils;
-    this.observableManager = observableManager;
   }
   transformElement(path17, scope, context2) {
     if (this.t.isJSXFragment(path17.node)) {
@@ -2030,18 +2478,10 @@ var ElementTransformer = class {
   processComponentAttributes(attributes, props, context2) {
     for (const attr of attributes) {
       if (this.t.isJSXSpreadAttribute(attr)) {
-        this.observableManager.collectObservables(
-          attr.argument,
-          context2.observables,
-          this.astUtils
-        );
-        const replaced = this.observableManager.replaceObservablesWithSignals(
-          attr.argument,
-          context2.observableSignals,
-          this.astUtils
-        );
         props.push(
-          this.t.spreadElement(this.astUtils.replaceThisWithSelf(replaced))
+          this.t.spreadElement(
+            this.astUtils.replaceThisWithSelf(attr.argument)
+          )
         );
         continue;
       }
@@ -2050,39 +2490,22 @@ var ElementTransformer = class {
         props.push(this.t.objectProperty(this.t.identifier(key), attr.value));
       } else if (this.t.isJSXExpressionContainer(attr.value)) {
         const expr = attr.value.expression;
-        this.observableManager.collectObservables(
-          expr,
-          context2.observables,
-          this.astUtils
-        );
-        if (this.guards.isSignalMember(expr) || this.guards.isBehaviorSubjectMember(expr)) {
-          const replaced = this.observableManager.replaceObservablesWithSignals(
-            expr,
-            context2.observableSignals,
-            this.astUtils
-          );
+        if (this.guards.isSignalMember(expr)) {
           props.push(
             this.t.objectMethod(
               "get",
               this.t.identifier(key),
               [],
               this.t.blockStatement([
-                this.t.returnStatement(
-                  this.astUtils.replaceThisWithSelf(replaced)
-                )
+                this.t.returnStatement(this.astUtils.replaceThisWithSelf(expr))
               ])
             )
           );
         } else {
-          const replaced = this.observableManager.replaceObservablesWithSignals(
-            expr,
-            context2.observableSignals,
-            this.astUtils
-          );
           props.push(
             this.t.objectProperty(
               this.t.identifier(key),
-              this.astUtils.replaceThisWithSelf(replaced)
+              this.astUtils.replaceThisWithSelf(expr)
             )
           );
         }
@@ -2105,22 +2528,12 @@ var ElementTransformer = class {
     let hrefValue = null;
     for (const attr of attributes) {
       if (this.t.isJSXSpreadAttribute(attr)) {
-        this.observableManager.collectObservables(
-          attr.argument,
-          context2.observables,
-          this.astUtils
-        );
-        const replaced = this.observableManager.replaceObservablesWithSignals(
-          attr.argument,
-          context2.observableSignals,
-          this.astUtils
-        );
         const effectCall = this.t.callExpression(this.t.identifier("$effect"), [
           this.t.arrowFunctionExpression(
             [],
             this.t.callExpression(this.t.identifier("$spread"), [
               elId,
-              this.astUtils.replaceThisWithSelf(replaced)
+              this.astUtils.replaceThisWithSelf(attr.argument)
             ])
           )
         ]);
@@ -2135,34 +2548,18 @@ var ElementTransformer = class {
       if (key === "ref") {
         hasRef = true;
         if (this.t.isJSXExpressionContainer(attr.value)) {
-          this.observableManager.collectObservables(
-            attr.value.expression,
-            context2.observables,
-            this.astUtils
-          );
-          const replaced = this.observableManager.replaceObservablesWithSignals(
-            attr.value.expression,
-            context2.observableSignals,
-            this.astUtils
+          refValue = this.astUtils.replaceThisWithSelf(
+            attr.value.expression
           );
-          refValue = this.astUtils.replaceThisWithSelf(replaced);
         }
         continue;
       }
       if (key === "dangerouslySetInnerHTML") {
         hasDangerousHTML = true;
         if (this.t.isJSXExpressionContainer(attr.value)) {
-          this.observableManager.collectObservables(
-            attr.value.expression,
-            context2.observables,
-            this.astUtils
+          dangerousHTMLValue = this.astUtils.replaceThisWithSelf(
+            attr.value.expression
           );
-          const replaced = this.observableManager.replaceObservablesWithSignals(
-            attr.value.expression,
-            context2.observableSignals,
-            this.astUtils
-          );
-          dangerousHTMLValue = this.astUtils.replaceThisWithSelf(replaced);
         }
         continue;
       }
@@ -2180,9 +2577,9 @@ var ElementTransformer = class {
         this.processStyleAttribute(attr, elId, statements, scope, context2);
         continue;
       }
-      this.processRegularAttribute(key, attr, elId, statements, context2);
+      this.processRegularAttribute(key, attr, elId, statements, scope, context2);
     }
-    if (tag === "a" && !hasClickHandler && hrefValue && this.isRelativeUrl(hrefValue)) {
+    if (tag === "a" && !hasClickHandler) {
       statements.push(
         this.t.expressionStatement(
           this.t.callExpression(
@@ -2193,13 +2590,25 @@ var ElementTransformer = class {
             [
               this.t.stringLiteral("click"),
               this.t.arrowFunctionExpression(
-                [this.t.identifier("event")],
+                [this.t.identifier("e")],
                 this.t.callExpression(
                   this.t.memberExpression(
                     this.t.identifier("Orca"),
                     this.t.identifier("navigate")
                   ),
-                  [this.t.identifier("event"), this.t.stringLiteral(hrefValue)]
+                  [
+                    this.t.identifier("e"),
+                    this.t.callExpression(
+                      this.t.memberExpression(
+                        this.t.memberExpression(
+                          this.t.identifier("e"),
+                          this.t.identifier("currentTarget")
+                        ),
+                        this.t.identifier("getAttribute")
+                      ),
+                      [this.t.stringLiteral("href")]
+                    )
+                  ]
                 )
               )
             ]
@@ -2224,17 +2633,9 @@ var ElementTransformer = class {
     const eventName = key.slice(2).toLowerCase();
     let handler = this.t.nullLiteral();
     if (this.t.isJSXExpressionContainer(attr.value)) {
-      this.observableManager.collectObservables(
-        attr.value.expression,
-        context2.observables,
-        this.astUtils
-      );
-      const replaced = this.observableManager.replaceObservablesWithSignals(
-        attr.value.expression,
-        context2.observableSignals,
-        this.astUtils
+      handler = this.astUtils.replaceThisWithSelf(
+        attr.value.expression
       );
-      handler = this.astUtils.replaceThisWithSelf(replaced);
     }
     statements.push(
       this.t.expressionStatement(
@@ -2247,56 +2648,63 @@ var ElementTransformer = class {
   }
   processStyleAttribute(attr, elId, statements, scope, context2) {
     if (!this.t.isJSXExpressionContainer(attr.value)) return;
-    this.observableManager.collectObservables(
-      attr.value.expression,
-      context2.observables,
-      this.astUtils
-    );
-    const replaced = this.observableManager.replaceObservablesWithSignals(
-      attr.value.expression,
-      context2.observableSignals,
-      this.astUtils
-    );
     const effectCall = this.t.callExpression(this.t.identifier("$effect"), [
       this.t.arrowFunctionExpression(
         [],
         this.t.callExpression(this.t.identifier("$style"), [
           elId,
-          this.astUtils.replaceThisWithSelf(replaced)
+          this.astUtils.replaceThisWithSelf(
+            attr.value.expression
+          )
         ])
       )
     ]);
     const cleanupStatements = this.astUtils.addEffectCleanup(scope, effectCall);
     statements.push(...cleanupStatements);
   }
-  processRegularAttribute(key, attr, elId, statements, context2) {
+  processRegularAttribute(key, attr, elId, statements, scope, context2) {
     const attrName = key === "className" ? "class" : key;
     let value;
+    let isReactive = false;
     if (this.t.isStringLiteral(attr.value)) {
       value = attr.value;
     } else if (this.t.isJSXExpressionContainer(attr.value)) {
-      this.observableManager.collectObservables(
-        attr.value.expression,
-        context2.observables,
-        this.astUtils
+      const expr = this.astUtils.replaceThisWithSelf(
+        attr.value.expression
       );
-      const replaced = this.observableManager.replaceObservablesWithSignals(
-        attr.value.expression,
-        context2.observableSignals,
-        this.astUtils
+      isReactive = this.guards.isSignalMember(
+        attr.value.expression
       );
-      value = this.astUtils.replaceThisWithSelf(replaced);
+      value = expr;
     } else {
       value = this.t.booleanLiteral(true);
     }
-    statements.push(
-      this.t.expressionStatement(
-        this.t.callExpression(
-          this.t.memberExpression(elId, this.t.identifier("setAttribute")),
-          [this.t.stringLiteral(attrName), value]
+    if (isReactive) {
+      const effectCall = this.t.callExpression(this.t.identifier("$effect"), [
+        this.t.arrowFunctionExpression(
+          [],
+          this.t.assignmentExpression(
+            "=",
+            this.t.memberExpression(elId, this.t.identifier(attrName)),
+            value
+          )
         )
-      )
-    );
+      ]);
+      const cleanupStatements = this.astUtils.addEffectCleanup(
+        scope,
+        effectCall
+      );
+      statements.push(...cleanupStatements);
+    } else {
+      statements.push(
+        this.t.expressionStatement(
+          this.t.callExpression(
+            this.t.memberExpression(elId, this.t.identifier("setAttribute")),
+            [this.t.stringLiteral(attrName), value]
+          )
+        )
+      );
+    }
   }
   processChildren(children, childExpressions, statements, scope, context2) {
     for (const child of children) {
@@ -2306,17 +2714,9 @@ var ElementTransformer = class {
       } else if (this.t.isJSXExpressionContainer(child)) {
         const expr = child.expression;
         if (!this.t.isJSXEmptyExpression(expr)) {
-          this.observableManager.collectObservables(
-            expr,
-            context2.observables,
-            this.astUtils
+          childExpressions.push(
+            this.astUtils.replaceThisWithSelf(expr)
           );
-          const replaced = this.observableManager.replaceObservablesWithSignals(
-            expr,
-            context2.observableSignals,
-            this.astUtils
-          );
-          childExpressions.push(this.astUtils.replaceThisWithSelf(replaced));
         }
       } else if (this.t.isJSXElement(child) || this.t.isJSXFragment(child)) {
         const childEl = this.transformElement({ node: child }, scope, context2);
@@ -2341,42 +2741,43 @@ var ElementTransformer = class {
       } else if (this.t.isJSXExpressionContainer(child)) {
         const expr = child.expression;
         if (this.t.isJSXEmptyExpression(expr)) continue;
-        this.observableManager.collectObservables(
-          expr,
-          context2.observables,
-          this.astUtils
-        );
-        let insertedValue;
-        if (this.guards.isSignalMember(expr)) {
-          insertedValue = this.astUtils.getObject(
-            expr
-          );
-        } else if (this.guards.isBehaviorSubjectMember(expr)) {
-          const replaced = this.observableManager.replaceObservablesWithSignals(
+        if (this.t.isLogicalExpression(expr, { operator: "&&" })) {
+          this.processConditionalAnd(
             expr,
-            context2.observableSignals,
-            this.astUtils
+            parentId,
+            statements,
+            scope,
+            context2
           );
-          insertedValue = this.astUtils.getObject(replaced);
-        } else {
-          const replaced = this.observableManager.replaceObservablesWithSignals(
+        } else if (this.t.isConditionalExpression(expr)) {
+          this.processConditionalTernary(
             expr,
-            context2.observableSignals,
-            this.astUtils
+            parentId,
+            statements,
+            scope,
+            context2
           );
-          insertedValue = this.t.arrowFunctionExpression(
-            [],
-            this.astUtils.replaceThisWithSelf(replaced)
+        } else {
+          let insertedValue;
+          if (this.guards.isSignalMember(expr)) {
+            insertedValue = this.astUtils.getObject(
+              expr
+            );
+          } else {
+            insertedValue = this.t.arrowFunctionExpression(
+              [],
+              this.astUtils.replaceThisWithSelf(expr)
+            );
+          }
+          statements.push(
+            this.t.expressionStatement(
+              this.t.callExpression(this.t.identifier("$insert"), [
+                parentId,
+                insertedValue
+              ])
+            )
           );
         }
-        statements.push(
-          this.t.expressionStatement(
-            this.t.callExpression(this.t.identifier("$insert"), [
-              parentId,
-              insertedValue
-            ])
-          )
-        );
       } else if (this.t.isJSXElement(child) || this.t.isJSXFragment(child)) {
         const childEl = this.transformElement({ node: child }, scope, context2);
         statements.push(...childEl.statements);
@@ -2391,18 +2792,137 @@ var ElementTransformer = class {
       }
     }
   }
+  processConditionalAnd(expr, parentId, statements, scope, context2) {
+    const condition = expr.left;
+    const consequent = expr.right;
+    const computedId = scope.generateUidIdentifier("c");
+    const branchExpr = this.transformExpressionToBranch(
+      consequent,
+      scope,
+      context2
+    );
+    statements.push(
+      this.t.expressionStatement(
+        this.t.callExpression(this.t.identifier("$insert"), [
+          parentId,
+          this.t.callExpression(
+            this.t.arrowFunctionExpression(
+              [],
+              this.t.blockStatement([
+                this.t.variableDeclaration("var", [
+                  this.t.variableDeclarator(
+                    computedId,
+                    this.t.callExpression(this.t.identifier("$computed"), [
+                      this.t.arrowFunctionExpression(
+                        [],
+                        this.astUtils.replaceThisWithSelf(condition)
+                      )
+                    ])
+                  )
+                ]),
+                this.t.returnStatement(
+                  this.t.arrowFunctionExpression(
+                    [],
+                    this.t.logicalExpression(
+                      "&&",
+                      this.t.memberExpression(
+                        computedId,
+                        this.t.identifier("value")
+                      ),
+                      this.t.callExpression(branchExpr, [])
+                    )
+                  )
+                )
+              ])
+            ),
+            []
+          )
+        ])
+      )
+    );
+  }
+  processConditionalTernary(expr, parentId, statements, scope, context2) {
+    const condition = expr.test;
+    const consequent = expr.consequent;
+    const alternate = expr.alternate;
+    const computedId = scope.generateUidIdentifier("c");
+    const trueBranchExpr = this.transformExpressionToBranch(
+      consequent,
+      scope,
+      context2
+    );
+    const falseBranchExpr = this.transformExpressionToBranch(
+      alternate,
+      scope,
+      context2
+    );
+    statements.push(
+      this.t.expressionStatement(
+        this.t.callExpression(this.t.identifier("$insert"), [
+          parentId,
+          this.t.callExpression(
+            this.t.arrowFunctionExpression(
+              [],
+              this.t.blockStatement([
+                this.t.variableDeclaration("var", [
+                  this.t.variableDeclarator(
+                    computedId,
+                    this.t.callExpression(this.t.identifier("$computed"), [
+                      this.t.arrowFunctionExpression(
+                        [],
+                        this.astUtils.replaceThisWithSelf(condition)
+                      )
+                    ])
+                  )
+                ]),
+                this.t.returnStatement(
+                  this.t.arrowFunctionExpression(
+                    [],
+                    this.t.conditionalExpression(
+                      this.t.memberExpression(
+                        computedId,
+                        this.t.identifier("value")
+                      ),
+                      this.t.callExpression(trueBranchExpr, []),
+                      this.t.callExpression(falseBranchExpr, [])
+                    )
+                  )
+                )
+              ])
+            ),
+            []
+          )
+        ])
+      )
+    );
+  }
+  transformExpressionToBranch(node, scope, context2) {
+    if (this.t.isJSXElement(node) || this.t.isJSXFragment(node)) {
+      const { id, statements } = this.transformElement(
+        { node },
+        scope,
+        context2
+      );
+      return this.t.arrowFunctionExpression(
+        [],
+        this.t.blockStatement([...statements, this.t.returnStatement(id)])
+      );
+    }
+    return this.t.arrowFunctionExpression(
+      [],
+      this.astUtils.replaceThisWithSelf(node)
+    );
+  }
 };
 function j2d({ types: t }) {
   const guards = new NodeTypeGuards(t);
   const astUtils = new ASTUtilities(t, guards);
   const jsxUtils = new JSXUtilities(t);
-  const observableManager = new ObservableManager(t, guards);
   const elementTransformer = new ElementTransformer(
     t,
     guards,
     astUtils,
-    jsxUtils,
-    observableManager
+    jsxUtils
   );
   return {
     name: "jsx-to-dom",
@@ -2415,8 +2935,8 @@ function j2d({ types: t }) {
             { local: "$createComponent", imported: "createComponent" },
             { local: "$style", imported: "style" },
             { local: "$spread", imported: "spread" },
-            { local: "$toSignal", imported: "toSignal" },
-            { local: "$effect", imported: "effect" }
+            { local: "$effect", imported: "effect" },
+            { local: "$computed", imported: "computed" }
           ];
           for (const helper of helpers) {
             path17.unshiftContainer(
@@ -2450,49 +2970,12 @@ function j2d({ types: t }) {
         path17.setData("processed", true);
         const body = path17.node.body;
         if (!t.isBlockStatement(body)) return;
-        const observables = /* @__PURE__ */ new Map();
-        path17.traverse({
-          JSXElement(jsxPath) {
-            observableManager.collectObservables(
-              jsxPath.node,
-              observables,
-              astUtils
-            );
-          },
-          JSXFragment(jsxPath) {
-            observableManager.collectObservables(
-              jsxPath.node,
-              observables,
-              astUtils
-            );
-          }
-        });
         body.body.unshift(
           t.variableDeclaration("const", [
             t.variableDeclarator(t.identifier("self"), t.thisExpression())
           ])
         );
-        const observableSignals = /* @__PURE__ */ new Map();
-        const signalDeclarations = [];
-        for (const [key, observable] of observables) {
-          const signalId = path17.scope.generateUidIdentifier("sig");
-          observableSignals.set(key, signalId);
-          signalDeclarations.push(
-            t.variableDeclaration("const", [
-              t.variableDeclarator(
-                signalId,
-                t.callExpression(t.identifier("$toSignal"), [
-                  observable,
-                  t.identifier("self")
-                ])
-              )
-            ])
-          );
-        }
-        if (signalDeclarations.length > 0) {
-          astUtils.insertBeforeReturn(body.body, signalDeclarations);
-        }
-        const context2 = { observables, observableSignals };
+        const context2 = { signals: /* @__PURE__ */ new Map() };
         path17.traverse({
           JSXElement(jsxPath) {
             if (jsxPath.getData("processed")) return;
@@ -2537,7 +3020,7 @@ function j2d({ types: t }) {
 }
 
 // src/plugins/generators/generate_server_component.ts
-import { parseSync as parseSync3, printSync as printSync2 } from "@swc/core";
+import { parseSync as parseSync3, printSync as printSync3 } from "@swc/core";
 function generateServerComponent(filePath, code) {
   const ast = parseSync3(code, {
     syntax: "typescript",
@@ -2579,7 +3062,7 @@ function generateServerComponent(filePath, code) {
       preservedNodes.push(item);
     }
   }
-  const preservedCode = preservedNodes.length > 0 ? printSync2({
+  const preservedCode = preservedNodes.length > 0 ? printSync3({
     type: "Module",
     span: ast.span,
     body: preservedNodes,
@@ -2614,7 +3097,7 @@ function extractClassStub2(classDecl) {
   const constructorParams = [];
   if (classDecl.decorators) {
     for (const dec of classDecl.decorators) {
-      const str = stringifyDecorator2(dec);
+      const str = stringifyDecorator3(dec);
       if (str) decorators.push(str);
     }
   }
@@ -2639,8 +3122,8 @@ function extractClassStub2(classDecl) {
     methods
   };
 }
-function stringifyDecorator2(decorator) {
-  const exprCode = printSync2({
+function stringifyDecorator3(decorator) {
+  const exprCode = printSync3({
     type: "Module",
     span: { start: 0, end: 0, ctxt: 0 },
     body: [
@@ -2675,7 +3158,7 @@ function stringifyParam2(param) {
   let decorators = [];
   if (param.decorators) {
     for (const d of param.decorators) {
-      const str = stringifyDecorator2(d);
+      const str = stringifyDecorator3(d);
       if (str) decorators.push(str);
     }
   }
@@ -2870,10 +3353,11 @@ ${decoratorsStr}export class ${className} extends _OrcaComponent {
 }
 
 // src/plugins/generators/generate_rpc.ts
+import { printSync as printSync4 } from "@swc/core";
 function generateRpcStub(filePath, code) {
   try {
     const ast = parseTypeScript(filePath, code);
-    const serviceInfo = extractServiceInfo(ast, filePath, false);
+    const serviceInfo = extractServiceInfo(ast, filePath, false, true, true);
     if (!serviceInfo) {
       throw {
         type: "validation",
@@ -2881,7 +3365,6 @@ function generateRpcStub(filePath, code) {
         filePath
       };
     }
-    validateServiceInfo(serviceInfo, filePath);
     return generateStubCode2(serviceInfo);
   } catch (error) {
     if (error.type) {
@@ -2895,32 +3378,143 @@ function generateRpcStub(filePath, code) {
     };
   }
 }
+function hasMulterFileParams2(method) {
+  return method.params.some((param) => {
+    return param.type === "Array<Express.Multer.File>" || param.type === "Express.Multer.File[]" || param.type === "Express.Multer.File";
+  });
+}
+function getFileParams2(method) {
+  return method.params.filter(
+    (p) => p.type === "Array<Express.Multer.File>" || p.type === "Express.Multer.File[]" || p.type === "Express.Multer.File"
+  ).map((p) => ({
+    name: p.name,
+    type: p.type,
+    isArray: p.type.includes("Array") || p.type.includes("[]")
+  }));
+}
+function getNonFileParams2(method) {
+  return method.params.filter(
+    (p) => p.type !== "Array<Express.Multer.File>" && p.type !== "Express.Multer.File[]" && p.type !== "Express.Multer.File"
+  );
+}
+function collectSharedImports(serviceInfo) {
+  const allImports = [];
+  const seen = /* @__PURE__ */ new Set();
+  const sharedParams = serviceInfo.constructorParams.filter(
+    (c) => c.decorators?.some((d) => d === "@Shared()")
+  );
+  for (const param of sharedParams) {
+    if (param.imports) {
+      for (const imp of param.imports) {
+        const key = `${imp.identifier}:${imp.source}`;
+        if (!seen.has(key)) {
+          allImports.push(imp);
+          seen.add(key);
+        }
+      }
+    }
+  }
+  return allImports;
+}
+function generateImportStatements(imports) {
+  const importsBySource = /* @__PURE__ */ new Map();
+  for (const imp of imports) {
+    if (!importsBySource.has(imp.source)) {
+      importsBySource.set(imp.source, /* @__PURE__ */ new Set());
+    }
+    importsBySource.get(imp.source).add(imp.identifier);
+  }
+  const statements = [];
+  for (const [source, identifiers] of importsBySource) {
+    const identifierList = Array.from(identifiers).sort().join(", ");
+    statements.push(`import { ${identifierList} } from "${source}";`);
+  }
+  return statements.sort().join("\n");
+}
 function generateStubCode2(serviceInfo) {
   const className = serviceInfo.className;
   const basePath = serviceNameToPath(className);
   const methods = serviceInfo.methods.map((method) => generateMethod2(method, basePath, className)).join("\n\n");
   const hasStreamable = serviceInfo.methods.some((m) => m.isStreamable);
-  const imports = generateImports2(hasStreamable);
+  const sharedImports = collectSharedImports(serviceInfo);
+  const imports = generateImports2(hasStreamable, sharedImports);
+  let clientConstructorFields = serviceInfo.constructorParams.filter((c) => c.decorators?.some((d) => d === "@Shared()")).map((c) => {
+    const filteredDecorators = c.decorators?.filter((d) => d !== "@Shared()") || [];
+    const decoratorStr = filteredDecorators.length > 0 ? filteredDecorators.join("\n") + "\n" : "";
+    return `${decoratorStr}${c.accessibility}${c.isReadonly ? " readonly " : " "}${c.name}: ${c.type},`;
+  }).join("\n");
   return `${imports}
 
 @Injectable()
 export class ${className} {
+constructor(
+${clientConstructorFields}
+) {}
+
 ${methods}
 }`;
 }
-function generateImports2(hasStreamable) {
+function generateImports2(hasStreamable, sharedImports) {
   let imports = `import { Injectable } from "@kithinji/orca";
 `;
   if (hasStreamable) {
-    imports += `import { Observable } from "@kithinji/orca";
+    imports += `import { Observable } from "rxjs";
 `;
   }
+  if (sharedImports.length > 0) {
+    const sharedImportStatements = generateImportStatements(sharedImports);
+    if (sharedImportStatements) {
+      imports += sharedImportStatements + "\n";
+    }
+  }
   return imports;
 }
 function generateMethod2(method, basePath, serviceName) {
+  if (method.lift) {
+    const classWrapper = {
+      type: "Module",
+      span: { start: 0, end: 0 },
+      body: [
+        {
+          type: "ClassDeclaration",
+          span: { start: 0, end: 0 },
+          declare: false,
+          ctxt: 0,
+          identifier: {
+            type: "Identifier",
+            value: "",
+            optional: false,
+            span: { start: 0, end: 0 },
+            ctxt: 0
+          },
+          body: [JSON.parse(JSON.stringify(method.ast))],
+          decorators: [],
+          superClass: null
+        }
+      ],
+      shebang: null
+    };
+    let { code } = printSync4(classWrapper);
+    const lines = code.split("\n");
+    lines.shift();
+    lines.pop();
+    lines.pop();
+    const methodCode = lines.join("\n");
+    return methodCode;
+  }
   if (method.isStreamable) {
+    if (hasMulterFileParams2(method)) {
+      throw new Error(
+        `Method '${method.name}' cannot have file parameters for streaming endpoints`
+      );
+    }
     return generateSseMethod(method, basePath);
   }
+  const fileParams = getFileParams2(method);
+  const hasFileParams = fileParams.length > 0;
+  if (hasFileParams) {
+    return generateFileUploadMethod2(method, basePath, fileParams);
+  }
   const params = method.params.map((p) => `${p.name}: ${p.type}`).join(", ");
   const hasParams = method.params.length > 0;
   if (!hasParams) {
@@ -2928,36 +3522,130 @@ function generateMethod2(method, basePath, serviceName) {
   }
   return generatePostMethod(method, basePath, params);
 }
+function generateFileUploadMethod2(method, basePath, fileParams) {
+  const allParams = method.params.map((p) => `${p.name}: ${p.type}`).join(", ");
+  const nonFileParams = getNonFileParams2(method);
+  const returnType = `Promise<${method.returnType}>`;
+  const lines = [];
+  lines.push(`    const formData = new FormData();`);
+  lines.push(``);
+  fileParams.forEach((fp) => {
+    if (fp.isArray) {
+      lines.push(`    if (${fp.name} && Array.isArray(${fp.name})) {`);
+      lines.push(`      ${fp.name}.forEach((file) => {`);
+      lines.push(`        formData.append('${fp.name}', file);`);
+      lines.push(`      });`);
+      lines.push(`    }`);
+    } else {
+      lines.push(`    if (${fp.name}) {`);
+      lines.push(`      formData.append('${fp.name}', ${fp.name});`);
+      lines.push(`    }`);
+    }
+  });
+  if (nonFileParams.length > 0) {
+    lines.push(``);
+    nonFileParams.forEach((p) => {
+      lines.push(`    if (${p.name} !== undefined) {`);
+      lines.push(
+        `      formData.append('${p.name}', typeof ${p.name} === 'object' ? JSON.stringify(${p.name}) : String(${p.name}));`
+      );
+      lines.push(`    }`);
+    });
+  }
+  lines.push(``);
+  lines.push(`    let headers = this.${method.name}Headers?.() || {};`);
+  lines.push(``);
+  lines.push(`    if(headers instanceof Promise) {`);
+  lines.push(`      headers = await headers;`);
+  lines.push(`    }`);
+  lines.push(``);
+  lines.push(
+    `    const response = await fetch(\`/api/${basePath}/${method.name}\`, {`
+  );
+  lines.push(`      method: 'POST',`);
+  lines.push(`      headers: {`);
+  lines.push(`        ...headers`);
+  lines.push(`      },`);
+  lines.push(`      body: formData,`);
+  lines.push(`    });`);
+  lines.push(``);
+  lines.push(`    if (!response.ok) {`);
+  lines.push(
+    `      throw new Error(\`HTTP error! status: \${response.status}\`);`
+  );
+  lines.push(`    }`);
+  lines.push(``);
+  lines.push(`    return response.json();`);
+  return `  async ${method.name}(${allParams}): ${returnType} {
+${lines.join("\n")}
+  }`;
+}
 function generateSseMethod(method, basePath) {
   const params = method.params.map((p) => `${p.name}: ${p.type}`).join(", ");
   const hasParams = method.params.length > 0;
   let urlBuilder;
+  const headerCheck = `this.${method.name}Headers`;
   if (hasParams) {
     const queryParams = method.params.map((p) => `${p.name}=\${encodeURIComponent(${p.name})}`).join("&");
-    urlBuilder = `\`/${basePath}/${method.name}?${queryParams}\``;
+    urlBuilder = `\`/api/${basePath}/${method.name}?${queryParams}\``;
   } else {
-    urlBuilder = `\`/${basePath}/${method.name}\``;
+    urlBuilder = `\`/api/${basePath}/${method.name}\``;
   }
   return `  ${method.name}(${params}): Observable<${method.returnType}> {
     return new Observable((observer) => {
-      const eventSource = new EventSource(${urlBuilder});
+      let url = ${urlBuilder};
 
-      eventSource.onmessage = (event) => {
-        try {
-          const data = JSON.parse(event.data);
-          observer.next(data);
-        } catch (error) {
-          observer.error?.(error);
+      // Get headers and append them as query parameters for SSE
+      const getHeaders = async () => {
+        let headers = ${headerCheck}?.() || {};
+        
+        if (headers instanceof Promise) {
+          headers = await headers;
+        }
+
+        // Convert headers to query parameters for EventSource
+        const headerParams = new URLSearchParams();
+        for (const [key, value] of Object.entries(headers)) {
+          headerParams.append(key, String(value));
         }
+
+        const headerString = headerParams.toString();
+        if (headerString) {
+          url += ${hasParams ? "`&${headerString}`" : "`?${headerString}`"};
+        }
+
+        const eventSource = new EventSource(url);
+
+        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();
+        };
       };
 
-      eventSource.onerror = (error) => {
+      getHeaders().then((cleanup) => {
+        // Store cleanup function for unsubscribe
+        if (cleanup) {
+          observer.add(cleanup);
+        }
+      }).catch((error) => {
         observer.error?.(error);
-        eventSource.close();
-      };
+      });
 
       return () => {
-        eventSource.close();
+        // Cleanup handled in getHeaders
       };
     });
   }`;
@@ -2966,10 +3654,17 @@ 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}\`, {
+    let headers = this.${method.name}Headers?.() || {};
+
+    if(headers instanceof Promise) {
+      headers = await headers;
+    }
+
+    const response = await fetch(\`/api/${basePath}/${method.name}\`, {
       method: 'GET',
       headers: {
         'Content-Type': 'application/json',
+        ...headers
       }
     });
 
@@ -2984,10 +3679,17 @@ 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}\`, {
+    let headers = this.${method.name}Headers?.() || {};
+
+    if(headers instanceof Promise) {
+      headers = await headers;
+    }
+
+    const response = await fetch(\`/api/${basePath}/${method.name}\`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
+        ...headers
       },
       body: JSON.stringify({ ${paramNames} }),
     });
@@ -3044,11 +3746,11 @@ function parseFileMetadata(source, path17) {
 }
 var ServerBuildTransformer = class {
   async transformPublicFile(source, path17) {
-    const controllerCode = generateController(path17, source);
-    if (controllerCode) {
-      source = `${source}
+    const result = generateController(path17, source);
+    if (result) {
+      source = `${result.transformedServiceCode}
 
-${controllerCode}
+${result.controllerCode}
 `;
     }
     return swcTransform(source, path17);
@@ -3183,7 +3885,48 @@ function useMyPlugin(options) {
 import { parseSync as parseSync4 } from "@swc/core";
 import * as fs3 from "fs";
 import * as path7 from "path";
+function findProjectRoot(startPath) {
+  let currentDir = path7.dirname(startPath);
+  while (currentDir !== path7.parse(currentDir).root) {
+    const packageJsonPath = path7.join(currentDir, "package.json");
+    if (fs3.existsSync(packageJsonPath)) {
+      return currentDir;
+    }
+    currentDir = path7.dirname(currentDir);
+  }
+  return process.cwd();
+}
+function resolvePathAlias(importPath, projectRoot) {
+  if (importPath.startsWith("@/")) {
+    const possiblePaths = [
+      path7.join(projectRoot, "src", importPath.slice(2)),
+      path7.join(projectRoot, importPath.slice(2))
+    ];
+    for (const possiblePath of possiblePaths) {
+      const extensions = ["", ".ts", ".tsx", ".js", ".jsx"];
+      for (const ext of extensions) {
+        const fullPath = possiblePath + ext;
+        if (fs3.existsSync(fullPath) && fs3.statSync(fullPath).isFile()) {
+          return fullPath;
+        }
+      }
+      const indexFiles = ["/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
+      for (const indexFile of indexFiles) {
+        const fullPath = possiblePath + indexFile;
+        if (fs3.existsSync(fullPath) && fs3.statSync(fullPath).isFile()) {
+          return fullPath;
+        }
+      }
+    }
+  }
+  return null;
+}
 function resolveFilePath(fromFile, importPath) {
+  if (importPath.startsWith("@/")) {
+    const projectRoot = findProjectRoot(fromFile);
+    const aliasResolved = resolvePathAlias(importPath, projectRoot);
+    if (aliasResolved) return aliasResolved;
+  }
   if (!importPath.startsWith(".")) return null;
   const dir = path7.dirname(fromFile);
   const basePath = path7.resolve(dir, importPath);
@@ -3606,7 +4349,7 @@ export async function navigate(event, url) {
     const injector = getCurrentInjector();
     
     if (injector) {
-      const navigate = injector.resolve(Navigate);
+      const navigate = await injector.resolve(Navigate);
       navigate.go(url);
     } else {
       window.location.href = url;
@@ -3669,7 +4412,7 @@ var HotReloadManager = class {
       });
     });
     this.logger.info(
-      `Hot reload server listening on ws://localhost:${this.port}`
+      `Hot reloads servers listening on ws://localhost:${this.port}`
     );
   }
   reload() {
@@ -4891,7 +5634,7 @@ function createPage(name) {
 import { ${listComponent} } from "./components/${name}-list.component";
 
 @Component({
-  deps: [${listComponent}]
+  inject: [${listComponent}]
 })
 export class ${pageName} {
     build() {
@@ -4987,7 +5730,8 @@ function genPackageJson(name) {
       "reflect-metadata": "latest",
       zod: "^4.2.1",
       "@kithinji/orca": "latest",
-      "@kithinji/arcane": "latest"
+      "@kithinji/arcane": "latest",
+      rxjs: "latest"
     },
     devDependencies: {
       "@types/node": "^20.19.27",
@@ -5010,6 +5754,7 @@ function gentsconfig() {
       jsxImportSource: "@kithinji/orca",
       experimentalDecorators: true,
       emitDecoratorMetadata: true,
+      strictPropertyInitialization: false,
       baseUrl: ".",
       paths: {
         "@/*": ["src/*"]
@@ -5056,7 +5801,7 @@ function genIndexHtml(name) {
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>${name} app</title>
-    <link rel="stylesheet" href="index.css" />
+    <link rel="stylesheet" href="/index.css" />
   </head>
   <body>
     <div id="root"></div>
@@ -5078,7 +5823,7 @@ import {
 } from "@kithinji/orca";
 
 @Component({
-  deps: [RouterOutlet],
+  inject: [RouterOutlet],
 })
 class AppComponent {
   build() {
@@ -5093,8 +5838,8 @@ class AppComponent {
 })
 class AppModule {}
 
-export function bootstrap() {
-  BrowserFactory.create(AppModule, document.getElementById("root")!);
+export async function bootstrap() {
+  await BrowserFactory.create(AppModule, document.getElementById("root")!);
 }
 
 bootstrap();
@@ -6769,7 +7514,7 @@ async function compileFiles(entryPoints) {
 
 // src/index.ts
 var program = new Command();
-program.name("pod").description("Pod cli tool").version("1.0.42");
+program.name("pod").description("Pod cli tool").version("1.0.46");
 program.command("new <name> [type]").description("Start a new Orca Project").action(async (name, type) => {
   const orca = async () => {
     await addNew(name);
@@ -6836,6 +7581,7 @@ program.command("deploy").description("Deploy to a target environment").argument
     process.exit(1);
   }
 });
+program.parse(process.argv);
 export {
   config_exports as config,
   expandMacros,
@@ -6846,7 +7592,6 @@ export {
   macros_exports as macros,
   mergeConfig,
   plugins_exports as plugins,
-  program,
   resetGlobalMacroGraph,
   store_exports as store,
   stylePlugin,