chore: reworking the types a little bit

Signed-off-by: blam <ben@blam.sh>

plugins/scaffolder-node/src/actions/createTemplateAction.ts

@@ -14,12 +14,37 @@
  * limitations under the License.
  */
 
-import { TemplateAction } from './types';
+import { ActionContext, TemplateAction } from './types';
 import { z } from 'zod';
 import { Schema } from 'jsonschema';
+import zodToJsonSchema from 'zod-to-json-schema';
+
+/** @public */
+export type TemplateActionOptions<
+  TParams = {},
+  TInputSchema extends Schema | z.ZodType = {},
+  TOutputSchema extends Schema | z.ZodType = {},
+> = {
+  id: string;
+  description?: string;
+  examples?: { description: string; example: string }[];
+  supportsDryRun?: boolean;
+  schema?: {
+    input?: TInputSchema;
+    output?: TOutputSchema;
+  };
+  handler: (
+    ctx: ActionContext<
+      TInputSchema extends z.ZodType<any, any, infer IReturn>
+        ? IReturn
+        : TParams
+    >,
+  ) => Promise<void>;
+};
+
 /**
  * This function is used to create new template actions to get type safety.
- *
+ * Will convert zod schemas to json schemas for use throughout the system.
  * @public
  */
 export const createTemplateAction = <
@@ -27,7 +52,26 @@ export const createTemplateAction = <
   TInputSchema extends Schema | z.ZodType = {},
   TOutputSchema extends Schema | z.ZodType = {},
 >(
-  templateAction: TemplateAction<TParams, TInputSchema, TOutputSchema>,
-): TemplateAction<TParams, TInputSchema, TOutputSchema> => {
-  return templateAction;
+  action: TemplateActionOptions<TParams, TInputSchema, TOutputSchema>,
+): TemplateAction<TParams> => {
+  const inputSchema =
+    action.schema?.input && 'safeParseAsync' in action.schema.input
+      ? zodToJsonSchema(action.schema.input)
+      : action.schema?.input;
+
+  const outputSchema =
+    action.schema?.output && 'safeParseAsync' in action.schema.output
+      ? zodToJsonSchema(action.schema.output)
+      : action.schema?.output;
+
+  const templateAction = {
+    ...action,
+    schema: {
+      ...action.schema,
+      input: inputSchema,
+      output: outputSchema,
+    },
+  };
+
+  return templateAction as TemplateAction<TParams>;
 };

plugins/scaffolder-node/src/actions/index.ts

@@ -14,5 +14,8 @@
  * limitations under the License.
  */
 
-export { createTemplateAction } from './createTemplateAction';
+export {
+  createTemplateAction,
+  type TemplateActionOptions,
+} from './createTemplateAction';
 export { type ActionContext, type TemplateAction } from './types';

plugins/scaffolder-node/src/actions/types.ts

@@ -16,17 +16,16 @@
 
 import { Logger } from 'winston';
 import { Writable } from 'stream';
-import { JsonValue, JsonObject } from '@backstage/types';
-import { Schema } from 'jsonschema';
+import { JsonValue } from '@backstage/types';
 import { TaskSecrets } from '../tasks/types';
 import { TemplateInfo } from '@backstage/plugin-scaffolder-common';
 import { UserEntity } from '@backstage/catalog-model';
-import { z } from 'zod';
+import { Schema } from 'jsonschema';
 /**
  * ActionContext is passed into scaffolder actions.
  * @public
  */
-export type ActionContext<TInput extends JsonObject> = {
+export type ActionContext<TInput = unknown> = {
   logger: Logger;
   logStream: Writable;
   secrets?: TaskSecrets;
@@ -63,24 +62,14 @@ export type ActionContext<TInput extends JsonObject> = {
 };
 
 /** @public */
-export type TemplateAction<
-  TParams = {},
-  TInputSchema extends Schema | z.ZodType = {},
-  TOutputSchema extends Schema | z.ZodType = {},
-> = {
+export type TemplateAction<TParams = unknown> = {
   id: string;
   description?: string;
   examples?: { description: string; example: string }[];
   supportsDryRun?: boolean;
   schema?: {
-    input?: TInputSchema;
-    output?: TOutputSchema;
+    input?: Schema;
+    output?: Schema;
   };
-  handler: (
-    ctx: ActionContext<
-      TInputSchema extends z.ZodType<any, any, infer IReturn>
-        ? IReturn
-        : TParams
-    >,
-  ) => Promise<void>;
+  handler: (ctx: ActionContext<TParams>) => Promise<void>;
 };