Update schema decorators and fix lint issue

Author: ajlai-orkes

src/sdk/worker/decorators/worker.ts

@@ -230,7 +230,7 @@ export function worker(options: WorkerOptions) {
       | string
       | { kind: string; name: string | symbol },
     descriptor?: PropertyDescriptor
-  ): T | PropertyDescriptor | void {
+  ): T | PropertyDescriptor | undefined {
     // Detect decorator API: new (Stage 3) vs legacy (experimentalDecorators)
     let executeFunction: (task: Task) => Promise<Omit<TaskResult, "workflowInstanceId" | "taskId">>;
     let isNewApi = false;
@@ -343,6 +343,6 @@ export function worker(options: WorkerOptions) {
       descriptor.value = dualModeFunction;
       return descriptor;
     }
-    return dualModeFunction;
+    return dualModeFunction as unknown as T;
   };
 }

src/sdk/worker/schema/__tests__/decorators.test.ts

@@ -174,4 +174,89 @@ describe("@schemaField() decorator", () => {
       expect(address.required).toEqual(["street"]);
     });
   });
+
+  describe("Stage 3 (TypeScript 5.0+) decorator API", () => {
+    it("should register fields when called with new decorator signature (value, context)", () => {
+      class TestClass {
+        name = "";
+      }
+      // Simulate new decorator API: decorator(value, context) returns initializer
+      const decorator = schemaField({ type: "string" });
+      const initializer = decorator(undefined, {
+        kind: "field",
+        name: "name",
+      }) as (initialValue: unknown) => unknown;
+      expect(typeof initializer).toBe("function");
+
+      // Initializer runs when instance is created; bind instance as `this`
+      const instance = new TestClass();
+      initializer.call(instance, "");
+
+      const schema = generateSchemaFromClass(TestClass);
+      expect(schema.properties).toEqual({ name: { type: "string" } });
+    });
+
+    it("should support required fields with new API", () => {
+      class TestClass {
+        id = "";
+        count = 0;
+      }
+      const initId = schemaField({ type: "string", required: true })(
+        undefined,
+        { kind: "field", name: "id" }
+      ) as (v: unknown) => unknown;
+      const initCount = schemaField({ type: "number" })(
+        undefined,
+        { kind: "field", name: "count" }
+      ) as (v: unknown) => unknown;
+
+      const instance = new TestClass();
+      initId.call(instance, "");
+      initCount.call(instance, 0);
+
+      const schema = generateSchemaFromClass(TestClass);
+      expect(schema.properties).toEqual({
+        id: { type: "string" },
+        count: { type: "number" },
+      });
+      expect(schema.required).toEqual(["id"]);
+    });
+
+    it("should not duplicate metadata when initializer runs multiple times", () => {
+      class TestClass {
+        value = "";
+      }
+      const initializer = schemaField({ type: "string" })(
+        undefined,
+        { kind: "field", name: "value" }
+      ) as (v: unknown) => unknown;
+
+      const i1 = new TestClass();
+      const i2 = new TestClass();
+      const i3 = new TestClass();
+      initializer.call(i1, "");
+      initializer.call(i2, "");
+      initializer.call(i3, "");
+
+      const schema = generateSchemaFromClass(TestClass);
+      expect(schema.properties).toEqual({ value: { type: "string" } });
+      expect(Object.keys(schema.properties)).toHaveLength(1);
+    });
+
+    it("should work with explicit type when design:type unavailable (new API)", () => {
+      class TestClass {
+        count = 0;
+      }
+      const initializer = schemaField({
+        type: "integer",
+        description: "Count",
+      })(undefined, { kind: "field", name: "count" }) as (v: unknown) => unknown;
+      initializer.call(new TestClass(), 0);
+
+      const schema = generateSchemaFromClass(TestClass);
+      expect(schema.properties).toEqual({
+        count: { type: "integer", description: "Count" },
+      });
+    });
+  });
 });

src/sdk/worker/schema/decorators.ts

@@ -38,15 +38,57 @@ interface StoredFieldMeta extends SchemaFieldOptions {
   designType?: unknown;
 }
 
+/**
+ * Type guard for Stage 3 (TypeScript 5.0+) decorator context.
+ * New decorators pass (value, context) where context has a `kind` property.
+ */
+function isNewDecoratorContext(
+  arg: unknown
+): arg is { kind: string; name: string | symbol } {
+  return (
+    typeof arg === "object" &&
+    arg !== null &&
+    "kind" in arg &&
+    typeof (arg as { kind: string }).kind === "string"
+  );
+}
+
+/**
+ * Track (class, propertyKey) pairs already stored to avoid duplicates when
+ * the initializer runs on each instance (Stage 3 decorator API).
+ */
+const schemaFieldProcessed = new WeakMap<object, Set<string>>();
+
+function storeSchemaFieldMetadata(
+  cls: object,
+  propertyKey: string,
+  options: SchemaFieldOptions,
+  designType?: unknown
+): void {
+  const existing: StoredFieldMeta[] =
+    (Reflect.getOwnMetadata(SCHEMA_METADATA_KEY, cls) as StoredFieldMeta[] | undefined) ?? [];
+
+  existing.push({
+    ...options,
+    propertyKey,
+    designType,
+  });
+
+  Reflect.defineMetadata(SCHEMA_METADATA_KEY, existing, cls);
+}
+
 /**
  * Property decorator to define JSON Schema metadata on a class.
  *
  * When used with `generateSchemaFromClass()`, produces a JSON Schema draft-07
  * object from the decorated properties.
  *
- * If `emitDecoratorMetadata` is enabled in tsconfig.json, the TypeScript type
- * is automatically inferred for `string`, `number`, `boolean` — no need to
- * specify `type` explicitly for those.
+ * Supports both TypeScript 5.0+ (Stage 3) and legacy (experimentalDecorators)
+ * decorator APIs.
+ *
+ * If `emitDecoratorMetadata` is enabled in tsconfig.json (legacy mode), the
+ * TypeScript type is automatically inferred for `string`, `number`, `boolean` —
+ * no need to specify `type` explicitly for those.
  *
  * @example
  * ```typescript
@@ -65,26 +107,46 @@ interface StoredFieldMeta extends SchemaFieldOptions {
  * ```
  */
 export function schemaField(options: SchemaFieldOptions = {}) {
-  return function (target: object, propertyKey: string) {
-    // Read existing field metadata for this class
-    const existing: StoredFieldMeta[] =
-      (Reflect.getOwnMetadata(SCHEMA_METADATA_KEY, target.constructor) as StoredFieldMeta[] | undefined) ?? [];
+  return function (
+    targetOrValue: object | undefined,
+    propertyKeyOrContext?: string | { kind: string; name: string | symbol }
+  ): ((initialValue: unknown) => unknown) | undefined {
+    if (isNewDecoratorContext(propertyKeyOrContext)) {
+      // Stage 3 (TypeScript 5.0+) API: (value, context)
+      // Return initializer that runs when instance is created; `this` = instance
+      const propertyKey = String(propertyKeyOrContext.name);
+      return function (this: unknown, initialValue: unknown) {
+        const cls = (this as object).constructor as object;
+        const processed = schemaFieldProcessed.get(cls) ?? new Set<string>();
+        if (!processed.has(propertyKey)) {
+          processed.add(propertyKey);
+          schemaFieldProcessed.set(cls, processed);
+          let designType: unknown;
+          try {
+            designType = Reflect.getMetadata(
+              "design:type",
+              this as object,
+              propertyKey
+            );
+          } catch {
+            // reflect-metadata may not emit design:type for Stage 3 decorators
+          }
+          storeSchemaFieldMetadata(cls, propertyKey, options, designType);
+        }
+        return initialValue;
+      };
+    }
 
-    // Try to infer type from TypeScript metadata
+    // Legacy (experimentalDecorators) API: (target, propertyKey)
+    const target = targetOrValue as object;
+    const propertyKey = propertyKeyOrContext as string;
     let designType: unknown;
     try {
       designType = Reflect.getMetadata("design:type", target, propertyKey);
     } catch {
       // reflect-metadata not available — user must provide type explicitly
     }
-
-    existing.push({
-      ...options,
-      propertyKey,
-      designType,
-    });
-
-    Reflect.defineMetadata(SCHEMA_METADATA_KEY, existing, target.constructor);
+    storeSchemaFieldMetadata(target.constructor as object, propertyKey, options, designType);
   };
 }