fix: bad typenames and internal policy (#979)

<!--
Pull requests are squashed and merged using:
- their title as the commit message
- their description as the commit body

Having a good title and description is important for the users to get
readable changelog.
-->

<!-- 1. Explain WHAT the change is about -->

- Fix bad duplicated typenames for duplicate materializers and
predefined internal policy function.

<!-- 3. Explain HOW users should update their code -->

#### Migration notes

---

- [x] The change comes with new or modified tests
- [ ] Hard-to-understand functions have explanatory comments
- [ ] End-user documentation is updated to reflect the change


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

## Summary by CodeRabbit

- **New Features**
- Enhanced access control with stricter authorization checks and refined
data exposure across different contexts.
- Introduced new type aliases for improved clarity in method return
types.
	- Added a new internal policy for access control.
- **Refactor**
- Streamlined naming for inputs and outputs to ensure consistent
labeling.
	- Adjusted evaluation logic to provide clearer security outcomes.
- **Tests**
- Expanded automated test scenarios to verify deduplication and
authorization behavior.
	- Added new test cases to validate internal policy access control.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: luckasRanarison

src/typegate/src/runtimes/deno/deno.ts

@@ -45,10 +45,8 @@ const predefinedFuncs: Record<
   pass: () => () => "PASS" as PolicyResolverOutput,
   internal_policy:
     () =>
-    ({ _: { context } }) =>
-      context.provider === "internal"
-        ? "ALLOW"
-        : ("PASS" as PolicyResolverOutput),
+    ({ _: { context } }): PolicyResolverOutput =>
+      context.provider === "internal" ? "PASS" : "DENY",
   context_check: ({ key, value }) => {
     let check: (value: any) => boolean;
     switch (value.type) {

src/typegraph/core/src/utils/postprocess/naming.rs

@@ -351,8 +351,8 @@ fn gen_name(cx: &VisitContext, acc: &mut VisitCollector, id: u32, ty_name: &str)
                 // we don't include optional and list nodes in
                 // generated names (useless but also, they might be placeholders)
                 Edge::OptionalItem | Edge::ArrayItem => continue,
-                Edge::FunctionInput => join_if_ok!(last_name.to_string(), "input"),
-                Edge::FunctionOutput => join_if_ok!(last_name.to_string(), "output"),
+                Edge::FunctionInput => format!("{}_input", last_name),
+                Edge::FunctionOutput => format!("{}_output", last_name),
                 Edge::ObjectProp(key) => {
                     join_if_ok!(format!("{last_name}_{key}"), ty_name)
                 }

tests/dedup/dedup_test.ts

@@ -4,31 +4,64 @@
 import { Meta } from "test-utils/mod.ts";
 import { Typegraph } from "@metatype/typegate/typegraph/types.ts";
 import { assert, assertEquals } from "@std/assert";
+import { FunctionNode } from "@metatype/typegate/typegraph/type_node.ts";
 
-Meta.test({
-  name: "dedup test",
-}, async (_t) => {
+Meta.test("dedup test", async ({ t }) => {
   const { stdout } = await Meta.cli(
     "serialize",
     "--pretty",
     "-f",
     "dedup/tg.ts",
   );
   const tg: Typegraph[] = JSON.parse(stdout);
+
   console.log(tg);
-  const ints = [];
-  const strs = [];
-  for (const ty of tg[0].types) {
-    if (ty.type == "integer") {
-      ints.push(ty);
-    }
-    if (ty.type == "string") {
-      strs.push(ty);
+
+  const [objTg, matTg] = tg;
+
+  await t.step("object dedup", () => {
+    const ints = [];
+    const strs = [];
+    for (const ty of objTg.types) {
+      if (ty.type == "integer") {
+        ints.push(ty);
+      }
+      if (ty.type == "string") {
+        strs.push(ty);
+      }
     }
-  }
-  assertEquals(ints.length, 2);
-  assert(ints.some((ty) => ty.title == "namedInt"));
-  assertEquals(strs.length, 3);
-  assert(strs.some((ty) => ty.format == "uuid"));
-  assertEquals(strs.filter((ty) => ty.format == "date-time").length, 1);
+    assertEquals(ints.length, 2);
+    assert(ints.some((ty) => ty.title == "namedInt"));
+    assertEquals(strs.length, 3);
+    assert(strs.some((ty) => ty.format == "uuid"));
+    assertEquals(strs.filter((ty) => ty.format == "date-time").length, 1);
+  });
+
+  await t.step("materializer dedup", () => {
+    const fnInput = matTg.types.findIndex(
+      ({ title }) => title === "root_f1_fn_input",
+    );
+    const fnOutput = matTg.types.findIndex(
+      ({ title }) => title === "root_f1_fn_output",
+    );
+
+    const f1 = matTg.types.find(
+      ({ title }) => title === "root_f1_fn",
+    ) as FunctionNode;
+    const f2 = matTg.types.find(
+      ({ title }) => title === "root_f2_fn",
+    ) as FunctionNode;
+
+    assertEquals(f1.input, fnInput);
+    assertEquals(f2.input, fnInput);
+    assertEquals(f1.output, fnOutput);
+    assertEquals(f2.output, fnOutput);
+  });
+
+  await t.step("unique type names", () => {
+    const typeNames = objTg.types.concat(matTg.types).map(({ title }) => title);
+    const nameSet = new Set(typeNames);
+
+    assertEquals(typeNames.length, nameSet.size);
+  });
 });

tests/dedup/tg.ts

@@ -3,8 +3,9 @@
 
 import { Policy, t, typegraph } from "@typegraph/sdk";
 import { RandomRuntime } from "@typegraph/sdk/runtimes/random";
+import { DenoRuntime } from "@typegraph/sdk/runtimes/deno";
 
-export const tg = await typegraph("dedup", (g: any) => {
+await typegraph("object-dedup", (g: any) => {
   const rand = new RandomRuntime({});
 
   const obj1 = t.struct({
@@ -26,8 +27,28 @@ export const tg = await typegraph("dedup", (g: any) => {
     dateInj2: t.datetime().inject("now"),
   });
 
+  g.expose(
+    {
+      test: rand.gen(obj1),
+      test2: rand.gen(obj2),
+    },
+    Policy.public(),
+  );
+});
+
+await typegraph("materializer-dedup", (g: any) => {
+  const deno = new DenoRuntime();
+
+  const f = deno.func(
+    t.struct({ i: t.integer() }),
+    t.struct({ o: t.string() }),
+    {
+      code: ({ i }) => ({ o: i.toString() }),
+    },
+  );
+
   g.expose({
-    test: rand.gen(obj1),
-    test2: rand.gen(obj2),
-  }, Policy.public());
+    f1: f.withPolicy(Policy.public()),
+    f2: f.withPolicy(Policy.internal()),
+  });
 });

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

@@ -302,7 +302,7 @@ snapshot[`typegraphs creation 2`] = `
       },
       {
         "type": "object",
-        "title": "struct_aada4",
+        "title": "root_add_fn_input",
         "properties": {
           "first": 3,
           "second": 3
@@ -316,7 +316,7 @@ snapshot[`typegraphs creation 2`] = `
       },
       {
         "type": "float",
-        "title": "float_9d392"
+        "title": "float_41db1"
       },
       {
         "type": "function",
@@ -454,7 +454,7 @@ snapshot[`typegraphs creation 3`] = `
       },
       {
         "type": "object",
-        "title": "struct_62ec9",
+        "title": "root_one_fn_input",
         "properties": {
           "a": 3,
           "b": 4
@@ -468,11 +468,11 @@ snapshot[`typegraphs creation 3`] = `
       },
       {
         "type": "integer",
-        "title": "struct_62ec9_a_integer"
+        "title": "root_one_fn_input_a_integer"
       },
       {
         "type": "integer",
-        "title": "struct_62ec9_b_integer",
+        "title": "root_one_fn_input_b_integer",
         "minimum": 12
       },
       {
@@ -971,7 +971,7 @@ snapshot[`typegraphs creation 5`] = `
       },
       {
         "type": "object",
-        "title": "struct_aada4",
+        "title": "root_add_fn_input",
         "properties": {
           "first": 3,
           "second": 3
@@ -985,7 +985,7 @@ snapshot[`typegraphs creation 5`] = `
       },
       {
         "type": "float",
-        "title": "float_9d392"
+        "title": "float_41db1"
       },
       {
         "type": "function",
@@ -1123,7 +1123,7 @@ snapshot[`typegraphs creation 6`] = `
       },
       {
         "type": "object",
-        "title": "struct_62ec9",
+        "title": "root_one_fn_input",
         "properties": {
           "a": 3,
           "b": 4
@@ -1137,11 +1137,11 @@ snapshot[`typegraphs creation 6`] = `
       },
       {
         "type": "integer",
-        "title": "struct_62ec9_a_integer"
+        "title": "root_one_fn_input_a_integer"
       },
       {
         "type": "integer",
-        "title": "struct_62ec9_b_integer",
+        "title": "root_one_fn_input_b_integer",
         "minimum": 12
       },
       {

tests/internal/py/logic_types.py

@@ -87,15 +87,15 @@ def new(dt_class: Any, val: Any):
 
 
 @dataclass
-class StructC3ed7(Struct):
+class RootSumFnInput(Struct):
     first: float
     second: float
 
 
-FORWARD_REFS["StructC3ed7"] = StructC3ed7
+FORWARD_REFS["RootSumFnInput"] = RootSumFnInput
 
 
-TypeFloatB5e57 = float
+TypeFloatD0c49 = float
 
 
 def __repr(value: Any):
@@ -104,10 +104,10 @@ def __repr(value: Any):
     return value
 
 
-def typed_remote_sum(user_fn: Callable[[StructC3ed7, Ctx], TypeFloatB5e57]):
+def typed_remote_sum(user_fn: Callable[[RootSumFnInput, Ctx], TypeFloatD0c49]):
     def exported_wrapper(raw_inp, ctx):
-        inp: StructC3ed7 = Struct.new(StructC3ed7, raw_inp)
-        out: TypeFloatB5e57 = user_fn(inp, ctx)
+        inp: RootSumFnInput = Struct.new(RootSumFnInput, raw_inp)
+        out: TypeFloatD0c49 = user_fn(inp, ctx)
         if isinstance(out, list):
             return [__repr(v) for v in out]
         return __repr(out)