feat: Parameter transformation

libs/common/src/typegraph/mod.rs

@@ -1,6 +1,7 @@
 // Copyright Metatype OÜ, licensed under the Elastic License 2.0.
 // SPDX-License-Identifier: Elastic-2.0
 
+pub mod parameter_transform;
 pub mod runtimes;
 pub mod types;
 pub mod utils;

libs/common/src/typegraph/parameter_transform.rs

@@ -0,0 +1,60 @@
+// Copyright Metatype OÜ, licensed under the Elastic License 2.0.
+// SPDX-License-Identifier: Elastic-2.0
+
+use std::collections::HashMap;
+
+#[cfg(feature = "codegen")]
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+#[cfg_attr(feature = "codegen", derive(JsonSchema))]
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(tag = "source", rename_all = "lowercase")]
+pub enum ParameterTransformLeafNode {
+    #[serde(rename_all = "camelCase")]
+    Arg { name: String },
+    #[serde(rename_all = "camelCase")]
+    Static { value_json: String },
+    #[serde(rename_all = "camelCase")]
+    Secret { key: String },
+    #[serde(rename_all = "camelCase")]
+    Context { key: String },
+    #[serde(rename_all = "camelCase")]
+    Parent { parent_idx: u32 },
+}
+
+#[cfg_attr(feature = "codegen", derive(JsonSchema))]
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(tag = "type", rename_all = "lowercase")]
+pub enum ParameterTransformParentNode {
+    #[serde(rename_all = "camelCase")]
+    Object {
+        fields: HashMap<String, ParameterTransformNode>,
+    },
+    #[serde(rename_all = "camelCase")]
+    Array { items: Vec<ParameterTransformNode> },
+}
+
+#[cfg_attr(feature = "codegen", derive(JsonSchema))]
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(untagged)]
+pub enum ParameterTransformNodeData {
+    Leaf(ParameterTransformLeafNode),
+    Parent(ParameterTransformParentNode),
+}
+
+#[cfg_attr(feature = "codegen", derive(JsonSchema))]
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct ParameterTransformNode {
+    pub type_idx: u32,
+    // #[serde(flatten)]
+    pub data: ParameterTransformNodeData,
+}
+
+#[cfg_attr(feature = "codegen", derive(JsonSchema))]
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct FunctionParameterTransform {
+    pub resolver_input: u32,
+    pub transform_root: ParameterTransformNode,
+}

libs/common/src/typegraph/types.rs

@@ -9,7 +9,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_with::skip_serializing_none;
 
-use super::{EffectType, PolicyIndices};
+use super::{parameter_transform::FunctionParameterTransform, EffectType, PolicyIndices};
 
 #[cfg_attr(feature = "codegen", derive(JsonSchema))]
 #[derive(Serialize, Deserialize, Clone, Debug)]
@@ -166,6 +166,8 @@ pub struct ListTypeData {
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct FunctionTypeData {
     pub input: u32,
+    #[serde(rename = "parameterTransform")]
+    pub parameter_transform: Option<FunctionParameterTransform>,
     pub output: u32,
     pub materializer: u32,
     #[serialize_always]

typegate/src/engine/planner/args.ts

@@ -24,13 +24,21 @@ import {
 import { mapValues } from "std/collections/map_values.ts";
 import { filterValues } from "std/collections/filter_values.ts";
 
-import { EffectType, EitherNode } from "../../typegraph/types.ts";
+import {
+  EffectType,
+  EitherNode,
+  FunctionParameterTransform,
+} from "../../typegraph/types.ts";
 
 import { getChildTypes, visitTypes } from "../../typegraph/visitor.ts";
 import { generateValidator } from "../typecheck/input.ts";
 import { getParentId } from "../stage_id.ts";
 import { BadContext } from "../../errors.ts";
 import { selectInjection } from "./injection_utils.ts";
+import {
+  compileParameterTransformer,
+  defaultParameterTransformer,
+} from "./parameter_transformer.ts";
 
 class MandatoryArgumentError extends Error {
   constructor(argDetails: string) {
@@ -84,6 +92,7 @@ export function collectArgs(
   parentProps: Record<string, number>,
   typeIdx: TypeIdx,
   astNodes: Record<string, ast.ArgumentNode>,
+  parameterTransform: FunctionParameterTransform | null,
 ): CollectedArgs {
   const collector = new ArgumentCollector(
     typegraph,
@@ -108,6 +117,13 @@ export function collectArgs(
   }
 
   const validate = generateValidator(typegraph, typeIdx);
+  const parameterTransformer = parameterTransform == null
+    ? defaultParameterTransformer
+    : compileParameterTransformer(
+      typegraph,
+      parentProps,
+      parameterTransform.transform_root,
+    );
 
   const policies = collector.policies;
 
@@ -124,7 +140,10 @@ export function collectArgs(
     // typecheck
     validate(value);
     return {
-      compute: () => value,
+      compute: (c) => {
+        const { parent, context } = c;
+        return parameterTransformer({ args: value, parent, context });
+      },
       deps: [],
       policies,
     };
@@ -136,7 +155,8 @@ export function collectArgs(
     compute: (params) => {
       const value = mapValues(compute, (c) => c(params));
       validate(value);
-      return value;
+      const { parent, context } = params;
+      return parameterTransformer({ args: value, parent, context });
     },
     deps: Array.from(collector.deps.parent).map((dep) => `${parentId}.${dep}`),
     policies,

typegate/src/engine/planner/mod.ts

@@ -411,8 +411,13 @@ export class Planner {
     }
 
     const schema = this.tg.type(node.typeIdx, Type.FUNCTION);
-    const { input: inputIdx, output: outputIdx, rate_calls, rate_weight } =
-      schema;
+    const {
+      input: inputIdx,
+      output: outputIdx,
+      rate_calls,
+      rate_weight,
+      parameterTransform = null,
+    } = schema;
     const outputType = this.tg.type(outputIdx);
 
     const mat = this.tg.materializer(schema.materializer);
@@ -440,6 +445,7 @@ export class Planner {
       parentProps,
       inputIdx,
       argNodes,
+      parameterTransform,
     );
 
     deps.push(...collected.deps);

typegate/src/engine/planner/parameter_transformer.ts

@@ -0,0 +1,161 @@
+// Copyright Metatype OÜ, licensed under the Elastic License 2.0.
+// SPDX-License-Identifier: Elastic-2.0
+
+import { TypeGraph } from "../../typegraph/mod.ts";
+import { ParameterTransformNode } from "../../typegraph/types.ts";
+
+export type TransformParamsInput = {
+  args: Record<string, any>;
+  context: Record<string, any>;
+  parent: Record<string, any>;
+};
+
+export function defaultParameterTransformer(input: TransformParamsInput) {
+  return input.args;
+}
+
+export type TransformParams = {
+  (input: TransformParamsInput): Record<string, any>;
+};
+
+export function compileParameterTransformer(
+  typegraph: TypeGraph,
+  parentProps: Record<string, number>,
+  transformerTreeRoot: ParameterTransformNode,
+): TransformParams {
+  const ctx = new TransformerCompilationContext(typegraph, parentProps);
+  const fnBody = ctx.compile(transformerTreeRoot);
+  const fn = new Function("input", fnBody) as TransformParams;
+  return (input) => {
+    const res = fn(input);
+    return res;
+  };
+}
+
+class TransformerCompilationContext {
+  #tg: TypeGraph;
+  #parentProps: Record<string, number>;
+  #path: string[] = [];
+  #latestVarIndex = 0;
+  #collector: string[] = [];
+
+  constructor(typegraph: TypeGraph, parentProps: Record<string, number>) {
+    this.#tg = typegraph;
+    this.#parentProps = parentProps;
+  }
+
+  #reset() {
+    this.#collector = [
+      "const { args, context, parent } = input;\n",
+    ];
+  }
+
+  compile(rootNode: ParameterTransformNode) {
+    this.#reset();
+    const varName = this.#compileNode(rootNode);
+    this.#collector.push(`return ${varName};`);
+    return this.#collector.join("\n");
+  }
+
+  #compileNode(node: ParameterTransformNode) {
+    const { typeIdx, data: nodeData } = node;
+    if ("type" in nodeData) {
+      switch (nodeData.type) {
+        case "object":
+          return this.#compileObject(typeIdx, nodeData.fields);
+        case "array":
+          return this.#compileArray(typeIdx, nodeData.items);
+        default:
+          // unreachable
+          throw new Error(
+            `Unknown type: ${(nodeData as any).type} at ${this.#path}`,
+          );
+      }
+    } else {
+      switch (nodeData.source) {
+        case "arg":
+          return this.#compileArgInjection(typeIdx, nodeData.name);
+        case "context":
+          return this.#compileContextInjection(typeIdx, nodeData.key);
+        case "secret":
+          return this.#compileSecretsInjection(typeIdx, nodeData.key);
+        case "parent":
+          return this.#compileParentInjection(typeIdx, nodeData.parentIdx);
+        default:
+          throw new Error(
+            `Unknown source: ${nodeData.source} at ${this.#path}`,
+          );
+      }
+    }
+  }
+
+  #compileObject(
+    _typeIdx: number, // TODO validation
+    fields: Record<string, ParameterTransformNode>,
+  ): string {
+    const varName = this.#createVarName();
+    this.#collector.push(`const ${varName} = {};`);
+
+    for (const [key, node] of Object.entries(fields)) {
+      const path = this.#path;
+      path.push(key);
+      const propVarName = this.#compileNode(node);
+      path.pop();
+      this.#collector.push(`${varName}["${key}"] = ${propVarName};`);
+    }
+
+    return varName;
+  }
+
+  #compileArray(_typeIdx: number, items: ParameterTransformNode[]) {
+    const varName = this.#createVarName();
+    this.#collector.push(`const ${varName} = [];`);
+
+    for (let i = 0; i < items.length; i++) {
+      const path = this.#path;
+      path.push(i.toString());
+      const propVarName = this.#compileNode(items[i]);
+      path.pop();
+      this.#collector.push(`${varName}.push(${propVarName});`);
+    }
+
+    return varName;
+  }
+
+  #compileArgInjection(_typeIdx: number, name: string) {
+    // TODO type validation ?
+    const varName = this.#createVarName();
+    this.#collector.push(`const ${varName} = args["${name}"];`);
+    return varName;
+  }
+
+  #compileContextInjection(_typeIdx: number, key: string) {
+    // TODO type validation ?
+    const varName = this.#createVarName();
+    this.#collector.push(`const ${varName} = context["${key}"];`);
+    return varName;
+  }
+
+  // return () => this.tg.parseSecret(typ, secretName);
+  #compileSecretsInjection(typeIdx: number, key: string) {
+    const secret = this.#tg.parseSecret(this.#tg.type(typeIdx), key);
+    // TODO type validation ? -- only additional constraints
+    const varName = this.#createVarName();
+    this.#collector.push(`const ${varName} = ${JSON.stringify(secret)};`);
+    return varName;
+  }
+
+  #compileParentInjection(_typeIdx: number, parentIdx: number) {
+    // TODO type validation ?
+    // TODO what if the value is lazy (a function?)
+    const [key] = Object.entries(this.#parentProps)
+      .find(([_key, idx]) => idx === parentIdx)!;
+    const varName = this.#createVarName();
+    this.#collector.push(`const ${varName} = parent["${key}"];`);
+    return varName;
+  }
+
+  #createVarName() {
+    return `var${++this.#latestVarIndex}`;
+  }
+}

typegate/src/typegraph/types.ts

@@ -147,6 +147,7 @@ export type FunctionNode = {
   };
   as_id: boolean;
   input: number;
+  parameterTransform?: FunctionParameterTransform | null;
   output: number;
   materializer: number;
   rate_weight?: number | null;
@@ -239,6 +240,34 @@ export type StringFormat =
   | "date"
   | "date-time"
   | "phone";
+export type ParameterTransformNodeData =
+  | ParameterTransformLeafNode
+  | ParameterTransformParentNode;
+export type ParameterTransformLeafNode = {
+  source: "arg";
+  name: string;
+} | {
+  source: "static";
+  valueJson: string;
+} | {
+  source: "secret";
+  key: string;
+} | {
+  source: "context";
+  key: string;
+} | {
+  source: "parent";
+  parentIdx: number;
+};
+export type ParameterTransformParentNode = {
+  type: "object";
+  fields: {
+    [k: string]: ParameterTransformNode;
+  };
+} | {
+  type: "array";
+  items: ParameterTransformNode[];
+};
 export type EffectType = "create" | "update" | "delete" | "read";
 export type TGRuntime = KnownRuntime | UnknownRuntime;
 export type KnownRuntime = {
@@ -362,6 +391,14 @@ export interface SingleValueFor_String {
 export interface SingleValueForUint32 {
   value: number;
 }
+export interface FunctionParameterTransform {
+  resolver_input: number;
+  transform_root: ParameterTransformNode;
+}
+export interface ParameterTransformNode {
+  typeIdx: number;
+  data: ParameterTransformNodeData;
+}
 export interface Materializer {
   name: string;
   runtime: number;