fix: correctly render decorators

Author: mrlubos

packages/openapi-python/src/plugins/@hey-api/sdk/v1/node.ts

@@ -68,19 +68,17 @@ function childToNode(
     plugin.config.operations.methodName.casing ?? 'camelCase',
   );
   const memberName = plugin.symbol(memberNameStr);
+  const cachedProp = plugin.external('functools.cached_property');
+
   return [
-    $.func(
-      memberName,
-      (f) => f.returns('None'),
-      // f.returns(refChild).do(
-      //   $('this')
-      //     .attr(privateName)
-      //     .nullishAssign(
-      //       $.new(refChild).args($.object().prop('client', $('this').attr('client'))),
-      //     )
-      //     .return(),
-      // ),
-    ),
+    $.func(memberName)
+      .decorator(cachedProp)
+      .returns(refChild)
+      .do(
+        $(refChild)
+          .call($.kwarg('client', $('self').attr('client')))
+          .return(),
+      ),
   ];
 }
 

packages/openapi-python/src/plugins/@hey-api/sdk/v1/plugin.ts

@@ -20,6 +20,14 @@ export const handlerV1: HeyApiSdkPlugin['Handler'] = ({ plugin }) => {
     },
   });
 
+  plugin.symbol('cached_property', {
+    external: 'functools',
+    meta: {
+      category: 'external',
+      resource: 'functools.cached_property',
+    },
+  });
+
   const structure = new StructureModel();
   const shell = createShell(plugin);
   const strategy = resolveStrategy(plugin);

packages/openapi-python/src/py-dsl/decl/func.ts

@@ -19,7 +19,7 @@ export class FuncPyDsl extends Mixed {
   override readonly nameSanitizer = safeRuntimeName;
 
   protected _parameters: Array<py.FunctionParameter> = [];
-  protected _returnType?: py.Expression;
+  protected _returnType?: NodeName | py.Expression;
 
   constructor(name: NodeName, fn?: (f: FuncPyDsl) => void) {
     super();
@@ -56,7 +56,7 @@ export class FuncPyDsl extends Mixed {
     return this;
   }
 
-  returns(returnType: string | py.Expression): this {
+  returns(returnType: NodeName | py.Expression): this {
     this._returnType =
       typeof returnType === 'string' ? py.factory.createIdentifier(returnType) : returnType;
     return this;

packages/openapi-python/src/py-dsl/mixins/decorator.ts

@@ -4,51 +4,43 @@ import { py } from '../../ts-python';
 import type { MaybePyDsl } from '../base';
 import type { BaseCtor, MixinCtor } from './types';
 
+type DecoratorInput = {
+  args: ReadonlyArray<MaybePyDsl<py.Expression>>;
+  name: NodeName | MaybePyDsl<py.Expression>;
+};
+
 export interface DecoratorMethods extends Node {
   $decorators(): ReadonlyArray<py.Expression>;
-  decorator(
-    name: NodeName | MaybePyDsl<py.Expression>,
-    ...args: ReadonlyArray<MaybePyDsl<py.Expression>>
-  ): this;
+  decorator(name: DecoratorInput['name'], ...args: DecoratorInput['args']): this;
 }
 
 export function DecoratorMixin<T extends py.Node, TBase extends BaseCtor<T>>(Base: TBase) {
   abstract class Decorator extends Base {
-    protected decorators: Array<py.Expression> = [];
+    protected _decorators: Array<DecoratorInput> = [];
 
     override analyze(ctx: AnalysisContext): void {
       super.analyze(ctx);
-      for (const decorator of this.decorators) {
-        ctx.analyze(decorator);
+      for (const decorator of this._decorators) {
+        ctx.analyze(decorator.name);
+        for (const arg of decorator.args) {
+          ctx.analyze(arg);
+        }
       }
     }
 
-    protected decorator(
-      name: NodeName | MaybePyDsl<py.Expression>,
-      ...args: ReadonlyArray<MaybePyDsl<py.Expression>>
-    ): this {
-      const nameNode =
-        typeof name === 'string' || isPyNode(name)
-          ? name
-          : py.factory.createIdentifier(String(name));
-      const decoratorExpr = args.length
-        ? py.factory.createCallExpression(
-            nameNode as py.Expression,
-            args.map((a) => this.$node(a)),
-          )
-        : (nameNode as py.Expression);
-      this.decorators.push(decoratorExpr);
+    protected decorator(name: DecoratorInput['name'], ...args: DecoratorInput['args']): this {
+      this._decorators.push({ args, name });
       return this;
     }
 
     protected $decorators(): ReadonlyArray<py.Expression> {
-      return this.decorators;
+      return this._decorators.map((decorator) =>
+        decorator.args.length > 0
+          ? py.factory.createCallExpression(this.$node(decorator.name), this.$node(decorator.args))
+          : this.$node(decorator.name),
+      );
     }
   }
 
   return Decorator as unknown as MixinCtor<TBase, DecoratorMethods>;
 }
-
-function isPyNode(value: unknown): value is { toAst(): unknown } {
-  return typeof value === 'object' && value !== null && 'toAst' in value;
-}