Merge branch 'main' into sdk-long-running-discovery

Author: michael-0acf4

libs/common/src/typegraph/mod.rs

@@ -98,6 +98,7 @@ pub struct TypeMeta {
     pub auths: Vec<Auth>,
     pub rate: Option<Rate>,
     pub version: String,
+    pub random_seed: Option<u32>,
 }
 
 #[cfg_attr(feature = "codegen", derive(JsonSchema))]

libs/common/src/typegraph/types.rs

@@ -50,6 +50,7 @@ pub enum Injection {
     Secret(InjectionData<String>),
     Parent(InjectionData<u32>),
     Dynamic(InjectionData<String>),
+    Random(InjectionData<String>),
 }
 
 #[cfg_attr(feature = "codegen", derive(JsonSchema))]
@@ -116,7 +117,6 @@ pub enum StringFormat {
     Ean,
     Date,
     DateTime,
-    // Path,
     Phone,
 }
 

typegate/deno.lock

@@ -245,7 +245,7 @@ class ArgumentCollector {
   private collectArgImpl(node: CollectNode): ComputeArg {
     const { astNode, typeIdx } = node;
 
-    const typ = this.tg.type(typeIdx);
+    const typ: TypeNode = this.tg.type(typeIdx);
 
     this.addPoliciesFrom(typeIdx);
 
@@ -695,6 +695,10 @@ class ArgumentCollector {
         }
         return generator;
       }
+
+      case "random": {
+        return () => this.tg.getRandom(typ);
+      }
     }
   }
 

typegate/src/engine/planner/args.ts

@@ -78,48 +78,106 @@ export class RandomRuntime extends Runtime {
 
   execute(typ: TypeNode): Resolver {
     return () => {
-      return this.randomizeRecursively(typ);
+      return randomizeRecursively(typ, this.chance, this._tgTypes);
     };
   }
+}
 
-  randomizeRecursively(typ: TypeNode): any {
-    const config = typ.config ?? {};
-    if (Object.prototype.hasOwnProperty.call(config, "gen")) {
-      const { gen, ...arg } = config;
-      return this.chance[gen as string](arg);
+export default function randomizeRecursively(
+  typ: TypeNode,
+  chance: typeof Chance,
+  tgTypes: TypeNode[],
+): any {
+  const config = typ.config ?? {};
+  if (Object.prototype.hasOwnProperty.call(config, "gen")) {
+    const { gen, ...arg } = config;
+    return chance[gen as string](arg);
+  }
+  switch (typ.type) {
+    case "object":
+      return {};
+    case "optional": {
+      const childNodeName = tgTypes[typ.item];
+      return chance.bool()
+        ? randomizeRecursively(childNodeName, chance, tgTypes)
+        : null;
     }
-    switch (typ.type) {
-      case "object":
-        return {};
-      case "optional": {
-        const childNodeName = this.getTgTypeNameByIndex(typ.item);
-        return this.chance.bool()
-          ? this.randomizeRecursively(childNodeName)
-          : null;
+    case "integer":
+      return chance.integer();
+    case "string":
+      if (typ.format === "uuid") {
+        return chance.guid();
+      }
+      if (typ.format === "email") {
+        return chance.email();
+      }
+      if (typ.format === "uri") {
+        return chance.url();
+      }
+      if (typ.format === "hostname") {
+        return chance.domain();
+      }
+      if (typ.format === "date-time") {
+        const randomDate = chance.date();
+
+        // Get the timestamp of the random date
+        const timestamp = randomDate.getTime();
+        console.log(randomDate);
+
+        // Create a new Date object with the timestamp adjusted for the local timezone offset
+        const dateInUtc = new Date(
+          timestamp - randomDate.getTimezoneOffset() * 60000,
+        );
+        return dateInUtc.toISOString();
+      }
+      if (typ.format === "phone") {
+        return chance.phone();
       }
-      case "integer":
-        return this.chance.integer();
-      case "string":
-        if (typ.format === "uuid") {
-          return this.chance.guid();
-        }
-        if (typ.format === "email") {
-          return this.chance.email();
-        }
-        return this.chance.string();
-      case "boolean":
-        return this.chance.bool();
-      case "list": {
-        const res = [];
-        let size = this.chance.integer({ min: 1, max: 10 });
-        const childNodeName = this.getTgTypeNameByIndex(typ.items);
-        while (size--) {
-          res.push(this.randomizeRecursively(childNodeName));
-        }
-        return res;
+      if (typ.format == "ean") {
+        return generateEAN(chance);
       }
-      default:
-        throw new Error(`type not supported "${typ.type}"`);
+      return chance.string();
+    case "boolean":
+      return chance.bool();
+    case "list": {
+      const res = [];
+      let size = chance.integer({ min: 1, max: 10 });
+      const childNodeName = tgTypes[typ.items];
+      while (size--) {
+        res.push(
+          randomizeRecursively(childNodeName, chance, tgTypes),
+        );
+      }
+      return res;
     }
+
+    default:
+      throw new Error(`type not supported "${typ.type}"`);
   }
 }
+
+function generateEAN(chance: typeof Chance) {
+  let ean = "0";
+
+  for (let i = 1; i <= 11; i++) {
+    ean += chance.integer({ min: 0, max: 9 }).toString();
+  }
+
+  const checkDigit = calculateCheckDigit(ean);
+  ean += checkDigit;
+
+  return ean;
+}
+
+function calculateCheckDigit(ean: string) {
+  const digits = ean.split("").map(Number);
+
+  let sum = 0;
+  for (let i = 0; i < digits.length; i++) {
+    sum += (i % 2 === 0) ? digits[i] : digits[i] * 3;
+  }
+
+  const checkDigit = (10 - (sum % 10)) % 10;
+
+  return checkDigit.toString();
+}

typegate/src/runtimes/random.ts

@@ -7,6 +7,7 @@ import type { DenoRuntime } from "../runtimes/deno/deno.ts";
 import { Runtime } from "../runtimes/Runtime.ts";
 import { ensure, ensureNonNullable } from "../utils.ts";
 import { typegraph_validate } from "native";
+import Chance from "chance";
 
 import {
   initAuth,
@@ -41,6 +42,7 @@ import type {
 import { InternalAuth } from "../services/auth/protocols/internal.ts";
 import { Protocol } from "../services/auth/protocols/protocol.ts";
 import { initRuntime } from "../runtimes/mod.ts";
+import randomizeRecursively from "../runtimes/random.ts";
 
 export { Cors, Rate, TypeGraphDS, TypeMaterializer, TypePolicy, TypeRuntime };
 
@@ -349,6 +351,30 @@ export class TypeGraph {
     );
   }
 
+  getRandom(
+    schema: TypeNode,
+  ): number | string | null {
+    const tgTypes: TypeNode[] = this.tg.types;
+    let seed = 12; // default seed
+    if (
+      this.tg.meta.random_seed !== undefined &&
+      this.tg.meta.random_seed !== null
+    ) {
+      seed = this.tg.meta.random_seed;
+    }
+    const chance: typeof Chance = new Chance(seed);
+
+    try {
+      const result = randomizeRecursively(schema, chance, tgTypes);
+
+      return result;
+    } catch (_) {
+      throw new Error(
+        `invalid type for random injection: ${schema.type}`,
+      );
+    }
+  }
+
   nextBatcher = (
     type: TypeNode,
   ): Batcher => {

typegate/src/typegraph/mod.ts

@@ -223,6 +223,9 @@ export type Injection = {
 } | {
   source: "dynamic";
   data: InjectionDataFor_String;
+} | {
+  source: "random";
+  data: InjectionDataFor_String;
 };
 export type InjectionDataFor_String = SingleValueFor_String | {
   [k: string]: string;
@@ -503,6 +506,7 @@ export interface TypeMeta {
   auths: Auth[];
   rate?: Rate | null;
   version: string;
+  random_seed: number | undefined;
 }
 export interface Queries {
   dynamic: boolean;

typegate/src/typegraph/types.ts

@@ -326,7 +326,8 @@ snapshot[`typegraphs creation 1`] = `
         "context_identifier": "user",
         "local_excess": 5
       },
-      "version": "0.0.3"
+      "version": "0.0.3",
+      "random_seed": null
     }
   }
 ]'
@@ -533,7 +534,8 @@ snapshot[`typegraphs creation 2`] = `
       },
       "auths": [],
       "rate": null,
-      "version": "0.0.3"
+      "version": "0.0.3",
+      "random_seed": null
     }
   }
 ]\`
@@ -815,7 +817,8 @@ snapshot[`typegraphs creation 3`] = `
       },
       "auths": [],
       "rate": null,
-      "version": "0.0.3"
+      "version": "0.0.3",
+      "random_seed": null
     }
   }
 ]\`
@@ -1147,7 +1150,8 @@ snapshot[`typegraphs creation 4`] = `
         "context_identifier": "user",
         "local_excess": 5
       },
-      "version": "0.0.3"
+      "version": "0.0.3",
+      "random_seed": null
     }
   }
 ]'
@@ -1354,7 +1358,8 @@ snapshot[`typegraphs creation 5`] = `
       },
       "auths": [],
       "rate": null,
-      "version": "0.0.3"
+      "version": "0.0.3",
+      "random_seed": null
     }
   }
 ]\`
@@ -1636,7 +1641,8 @@ snapshot[`typegraphs creation 6`] = `
       },
       "auths": [],
       "rate": null,
-      "version": "0.0.3"
+      "version": "0.0.3",
+      "random_seed": null
     }
   }
 ]\`

typegate/tests/e2e/typegraph/__snapshots__/typegraph_test.ts.snap

@@ -0,0 +1,48 @@
+from typegraph.policy import Policy
+from typegraph.runtimes.deno import DenoRuntime
+
+from typegraph import Graph, t, typegraph
+
+
+@typegraph()
+def random_injection(g: Graph):
+    pub = Policy.public()
+    deno = DenoRuntime()
+
+    user = t.struct(
+        {
+            "id": t.uuid().from_random(),
+            "ean": t.ean().from_random(),
+            "name": t.string(config={"gen": "name"}).from_random(),
+            "age": t.integer(config={"gen": "age", "type": "adult"}).from_random(),
+            "married": t.boolean().from_random(),
+            "birthday": t.datetime().from_random(),
+            "friends": t.list(t.string(config={"gen": "first"})).from_random(),
+            "phone": t.string(config={"gen": "phone"}).from_random(),
+            "gender": t.string(config={"gen": "gender"}).from_random(),
+            "firstname": t.string(config={"gen": "first"}).from_random(),
+            "lastname": t.string(config={"gen": "last"}).from_random(),
+            "occupation": t.string(config={"gen": "profession"}).from_random(),
+            "street": t.string(config={"gen": "address"}).from_random(),
+            "city": t.string(config={"gen": "city"}).from_random(),
+            "postcode": t.string(config={"gen": "postcode"}).from_random(),
+            "country": t.string(
+                config={"gen": "country", "full": "true"}
+            ).from_random(),
+            "uri": t.uri().from_random(),
+            "hostname": t.string(format="hostname").from_random(),
+        }
+    )
+
+    random_list = t.struct(
+        {
+            "names": t.list(t.string(config={"gen": "name"})).from_random(),
+        }
+    )
+    # Configure random injection seed value or the default will be used
+    g.configure_random_injection(seed=1)
+    g.expose(
+        pub,
+        randomUser=deno.identity(user),
+        randomList=deno.identity(random_list),
+    )