diff --git a/skipruntime-ts/helpers/src/index.ts b/skipruntime-ts/helpers/src/index.ts
index a1848dc25a..dbab20da87 100644
--- a/skipruntime-ts/helpers/src/index.ts
+++ b/skipruntime-ts/helpers/src/index.ts
@@ -14,3 +14,4 @@ export {
 export { SkipExternalService } from "./remote.js";
 export { SkipServiceBroker, fetchJSON, type Entrypoint } from "./rest.js";
 export { Count, Max, Min, Sum } from "./utils.js";
+export { join_one, join_many, join_many_through } from "./join.js";
diff --git a/skipruntime-ts/helpers/src/join.ts b/skipruntime-ts/helpers/src/join.ts
new file mode 100644
index 0000000000..9c2156252d
--- /dev/null
+++ b/skipruntime-ts/helpers/src/join.ts
@@ -0,0 +1,250 @@
+import type {
+  EagerCollection,
+  Json,
+  JsonObject,
+  Values,
+  Mapper,
+  DepSafe,
+} from "@skipruntime/core";
+
+class JoinOneMapper<
+  IdProperty extends keyof VLeft,
+  AsProperty extends string,
+  KLeft extends Json,
+  VLeft extends JsonObject & { [P in IdProperty]: Json },
+  VRight extends Json,
+> implements
+    Mapper<
+      KLeft,
+      VLeft,
+      KLeft,
+      Omit<VLeft, IdProperty> & Record<AsProperty, VRight>
+    >
+{
+  constructor(
+    private readonly right: EagerCollection<VLeft[IdProperty], VRight>,
+    private readonly id: IdProperty,
+    private readonly as: AsProperty,
+  ) {}
+
+  mapEntry(
+    key: KLeft,
+    values: Values<VLeft>,
+  ): Iterable<[KLeft, Omit<VLeft, IdProperty> & Record<AsProperty, VRight>]> {
+    return values.toArray().map((v: VLeft) => {
+      const { [this.id]: key_right, ...value_left } = v;
+      const value_right = {
+        [this.as]: this.right.getUnique(key_right),
+      } as Record<AsProperty, VRight>;
+      const value_out = { ...value_left, ...value_right };
+      return [key, value_out];
+    });
+  }
+}
+
+export function join_one<
+  IdProperty extends keyof VLeft,
+  AsProperty extends string,
+  KLeft extends Json,
+  VLeft extends JsonObject & { [P in IdProperty]: Json },
+  VRight extends Json,
+>(options: {
+  left: EagerCollection<KLeft, VLeft>;
+  right: EagerCollection<VLeft[IdProperty], VRight>;
+  id: IdProperty;
+  as: AsProperty;
+}): EagerCollection<
+  KLeft,
+  Omit<VLeft, IdProperty> & Record<AsProperty, VRight>
+> {
+  return options.left.map(
+    JoinOneMapper<IdProperty, AsProperty, KLeft, VLeft, VRight>,
+    options.right,
+    options.id,
+    options.as,
+  );
+}
+
+class ProjectionMapper<
+  ProjectionProperty extends keyof V,
+  K extends Json,
+  V extends JsonObject & { [P in ProjectionProperty]: Json },
+> implements Mapper<K, V, V[ProjectionProperty], V>
+{
+  constructor(private readonly proj_property: ProjectionProperty) {}
+
+  mapEntry(_key: K, values: Values<V>): Iterable<[V[ProjectionProperty], V]> {
+    return values.toArray().map((v: V) => {
+      return [v[this.proj_property], v];
+    });
+  }
+}
+
+class JoinManyMapper<
+  IdProperty extends keyof VRight,
+  AsProperty extends string,
+  K extends Json,
+  VLeft extends JsonObject,
+  VRight extends JsonObject & { [P in IdProperty]: Json },
+> implements
+    Mapper<
+      VRight[IdProperty],
+      VLeft,
+      VRight[IdProperty],
+      VLeft & Record<AsProperty, VRight[]>
+    >
+{
+  private readonly right: EagerCollection<VRight[IdProperty], VRight>;
+
+  constructor(
+    right: EagerCollection<K, VRight>,
+    on: IdProperty,
+    private readonly as: AsProperty,
+  ) {
+    this.right = right.map(ProjectionMapper<IdProperty, K, VRight>, on);
+  }
+
+  mapEntry(
+    key: VRight[IdProperty],
+    values: Values<VLeft>,
+  ): Iterable<[VRight[IdProperty], VLeft & Record<AsProperty, VRight[]>]> {
+    return values.toArray().map((value_left: VLeft) => {
+      const value_right = { [this.as]: this.right.getArray(key) } as Record<
+        AsProperty,
+        (VRight & DepSafe)[]
+      >;
+      const value_out = { ...value_left, ...value_right };
+      return [key, value_out];
+    });
+  }
+}
+
+class SelectionMapper<
+  P extends keyof V,
+  K extends Json,
+  V extends JsonObject & { [T in P]: Json },
+> implements Mapper<K, V, K, V[P]>
+{
+  constructor(private readonly prop: P) {}
+
+  mapEntry(key: K, values: Values<V>): Iterable<[K, V[P]]> {
+    return values.toArray().map((v) => {
+      return [key, v[this.prop]];
+    });
+  }
+}
+
+class JoinManyThroughMapper<
+  IdLeftProperty extends keyof VThrough,
+  IdRightProperty extends keyof VThrough,
+  AsProperty extends string,
+  VLeft extends JsonObject,
+  VRight extends Json,
+  KThrough extends Json,
+  VThrough extends JsonObject & {
+    [P in IdLeftProperty | IdRightProperty]: Json;
+  },
+> implements
+    Mapper<
+      VThrough[IdLeftProperty],
+      VLeft,
+      VThrough[IdLeftProperty],
+      VLeft & Record<AsProperty, VRight[]>
+    >
+{
+  private readonly through: EagerCollection<
+    VThrough[IdLeftProperty],
+    VThrough[IdRightProperty]
+  >;
+
+  constructor(
+    private readonly right: EagerCollection<VThrough[IdRightProperty], VRight>,
+    through: EagerCollection<KThrough, VThrough>,
+    id_left: IdLeftProperty,
+    id_right: IdRightProperty,
+    private readonly as: AsProperty,
+  ) {
+    this.through = through
+      .map(ProjectionMapper<IdLeftProperty, KThrough, VThrough>, id_left)
+      .map(
+        SelectionMapper<IdRightProperty, VThrough[IdLeftProperty], VThrough>,
+        id_right,
+      );
+  }
+
+  mapEntry(
+    key: VThrough[IdLeftProperty],
+    values: Values<VLeft>,
+  ): Iterable<
+    [VThrough[IdLeftProperty], VLeft & Record<AsProperty, VRight[]>]
+  > {
+    return values.toArray().map((value_left: VLeft) => {
+      const value_right = {
+        [this.as]: this.through
+          .getArray(key)
+          .map((id_right) => this.right.getUnique(id_right)),
+      } as Record<AsProperty, (VRight & DepSafe)[]>;
+      const value_out = { ...value_left, ...value_right };
+      return [key, value_out];
+    });
+  }
+}
+
+export function join_many_through<
+  IdLeftProperty extends keyof VThrough,
+  IdRightProperty extends keyof VThrough,
+  AsProperty extends string,
+  VLeft extends JsonObject,
+  VRight extends Json,
+  KThrough extends Json,
+  VThrough extends JsonObject & {
+    [P in IdLeftProperty | IdRightProperty]: Json;
+  },
+>(options: {
+  left: EagerCollection<VThrough[IdLeftProperty], VLeft>;
+  right: EagerCollection<VThrough[IdRightProperty], VRight>;
+  as: AsProperty;
+  id_left: IdLeftProperty;
+  id_right: IdRightProperty;
+  through: EagerCollection<KThrough, VThrough>;
+}): EagerCollection<
+  VThrough[IdLeftProperty],
+  VLeft & Record<AsProperty, VRight[]>
+> {
+  return options.left.map(
+    JoinManyThroughMapper<
+      IdLeftProperty,
+      IdRightProperty,
+      AsProperty,
+      VLeft,
+      VRight,
+      KThrough,
+      VThrough
+    >,
+    options.right,
+    options.through,
+    options.id_left,
+    options.id_right,
+    options.as,
+  );
+}
+
+export function join_many<
+  IdProperty extends keyof VRight,
+  AsProperty extends string,
+  KRight extends Json,
+  VLeft extends JsonObject,
+  VRight extends JsonObject & { [K in IdProperty]: Json },
+>(options: {
+  left: EagerCollection<VRight[IdProperty], VLeft>;
+  right: EagerCollection<KRight, VRight>;
+  id: IdProperty;
+  as: AsProperty;
+}): EagerCollection<VRight[IdProperty], VLeft & Record<AsProperty, VRight[]>> {
+  return options.left.map(
+    JoinManyMapper<IdProperty, AsProperty, KRight, VLeft, VRight>,
+    options.right,
+    options.id,
+    options.as,
+  );
+}
diff --git a/skipruntime-ts/tests/src/tests.ts b/skipruntime-ts/tests/src/tests.ts
index 218787989f..a97e86703f 100644
--- a/skipruntime-ts/tests/src/tests.ts
+++ b/skipruntime-ts/tests/src/tests.ts
@@ -21,6 +21,9 @@ import {
   GenericExternalService,
   Sum,
   TimerResource,
+  join_one,
+  join_many,
+  join_many_through,
 } from "@skipruntime/helpers";
 
 import { it as mit, type AsyncFunc } from "mocha";
@@ -759,6 +762,86 @@ const mapWithExceptionOnExternalService: SkipService<Input_SN, Input_SN> = {
   },
 };
 
+//// testJoinHelpers
+
+type Post = { title: string; author_id: number };
+type User = { name: string };
+type Upvote = { user_id: number; post_id: number };
+
+type JoinServiceInputs = {
+  posts: EagerCollection<number, Post>;
+  users: EagerCollection<number, User>;
+  upvotes: EagerCollection<number, Upvote>;
+};
+
+type PostWithAuthorAndUpvotes = Omit<Post, "author_id"> & {
+  author: User;
+  upvotes: Upvote[];
+};
+
+type PostWithAuthorAndUpvoters = Omit<Post, "author_id"> & {
+  author: User;
+  upvoters: User[];
+};
+
+type JoinServiceResourceInputs = {
+  posts1: EagerCollection<number, PostWithAuthorAndUpvotes>;
+  posts2: EagerCollection<number, PostWithAuthorAndUpvoters>;
+};
+
+class Posts1Resource implements Resource<JoinServiceResourceInputs> {
+  instantiate(
+    collections: JoinServiceResourceInputs,
+  ): EagerCollection<number, PostWithAuthorAndUpvotes> {
+    return collections.posts1;
+  }
+}
+
+class Posts2Resource implements Resource<JoinServiceResourceInputs> {
+  instantiate(
+    collections: JoinServiceResourceInputs,
+  ): EagerCollection<number, PostWithAuthorAndUpvoters> {
+    return collections.posts2;
+  }
+}
+
+const joinService: SkipService<JoinServiceInputs, JoinServiceResourceInputs> = {
+  initialData: {
+    posts: [],
+    users: [],
+    upvotes: [],
+  },
+  resources: {
+    posts1: Posts1Resource,
+    posts2: Posts2Resource,
+  },
+  createGraph(inputCollections: JoinServiceInputs) {
+    const posts_with_author = join_one(
+      {
+        left: inputCollections.posts,
+        right: inputCollections.users,
+        id: "author_id",
+        as: "author",
+      },
+    );
+    const posts1 = join_many({
+      left: posts_with_author,
+      right: inputCollections.upvotes,
+      id: "post_id",
+      as: "upvotes",
+    });
+    const posts2 = join_many_through({
+      left: posts_with_author,
+      right: inputCollections.users,
+      through: inputCollections.upvotes,
+      id_left: "post_id",
+      id_right: "user_id",
+      as: "upvoters",
+    });
+    return { posts1, posts2 };
+  },
+};
+
 export function initTests(
   category: string,
   initService: (service: SkipService) => Promise<ServiceInstance>,
@@ -1295,4 +1378,71 @@ export function initTests(
       new RegExp(/^(?:Error: )?Something goes wrong.$/),
     );
   });
+
+  it("testJoinHelpers", async () => {
+    const service = await initService(joinService);
+    try {
+      service.update("users", [
+        [1, [{ name: "Foo" }]],
+        [2, [{ name: "Bar" }]],
+      ]);
+      service.update("posts", [
+        [1, [{ title: "FooBar", author_id: 1 }]],
+        [2, [{ title: "Baz", author_id: 2 }]],
+      ]);
+      service.update("upvotes", [
+        [1, [{ post_id: 1, user_id: 1 }]],
+        [2, [{ post_id: 1, user_id: 2 }]],
+        [3, [{ post_id: 2, user_id: 2 }]],
+      ]);
+      service.instantiateResource("unsafe.fixed.resource.ident1", "posts1", {});
+      service.instantiateResource("unsafe.fixed.resource.ident2", "posts2", {});
+      expect(service.getAll("posts1").payload).toEqual([
+        [
+          1,
+          [
+            {
+              title: "FooBar",
+              author: { name: "Foo" },
+              upvotes: [{ post_id: 1, user_id: 1 }, { post_id: 1, user_id: 2 }],
+            },
+          ],
+        ],
+        [
+          2,
+          [
+            {
+              title: "Baz",
+              author: { name: "Bar" },
+              upvotes: [{ post_id: 2, user_id: 2 }],
+            },
+          ],
+        ],
+      ]);
+      expect(service.getAll("posts2").payload).toEqual([
+        [
+          1,
+          [
+            {
+              title: "FooBar",
+              author: { name: "Foo" },
+              upvoters: [{ name: "Foo" }, { name: "Bar" }],
+            },
+          ],
+        ],
+        [
+          2,
+          [
+            {
+              title: "Baz",
+              author: { name: "Bar" },
+              upvoters: [{ name: "Bar" }],
+            },
+          ],
+        ],
+      ]);
+    } finally {
+      await service.close();
+    }
+  });
 }